[JAVA]-集合相关扩展

[TOC]

Enum枚举

<1>枚举基础概念

​ JDK1.5引入了新的类型——枚举

<2>枚举相关应用

🔖应用1：常量分类

// 传统常量定义
public static fianl [type] [field] = [value]; 

// 枚举常量集合
public enum ColorEnum {  
  RED, GREEN, BLANK, YELLOW  
}  

🔖应用2：switch引用

// 自定义时间段枚举
enum TimeEnum{
    MORNING,MOON,EVERING
}

public class TimeEnumDemo {
    @Test
    public void test(){
        TimeEnum testParam = TimeEnum.MOON;
        switch (testParam){
            case MORNING:{
                System.out.println("MORNING");
                break;
            }
            case MOON:{
                System.out.println("MOON");
                break;
            }
            case EVERING:{

                System.out.println("MORNING");
                break;
            }
            default:{
                System.out.println("OTHER");
                break;
            }
        }
    }
}

🔖应用3：自定义枚举概念

自定义概念说明

​ 自定义枚举常用于应用设计，例如ErrorEnum概念（异常码定义）

枚举实例定义
成员变量、构造方法、普通方法（get/set构造器、自定义方法）、方法重载（toStrng）

import org.junit.Test;

// 自定义枚举
enum CustomEnum{

    // 定义enum实例
    MORNING(1,"MORNING"),
    MOON(2,"MOON"),
    EVENING(3,"EVENING")
    ;


    // a.定义成员变量
    private int key;
    private String value;


    // b.定义构造方法
    CustomEnum(int key, String value) {
        this.key = key;
        this.value = value;
    }


    // c.定义普通方法(get\set构造器,或者自定义扩展其他方法)
    public int getKey() {
        return key;
    }

    public void setKey(int key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    // 根据key获取指定的value
    public static String getValueByKey(int key){
        for (CustomEnum enumItem : CustomEnum.values()) {
            if(enumItem.getKey()==key){
                return enumItem.getValue();
            }
        }
        return null;
    }

    // d.覆盖方法(toString方法重载)

    @Override
    public String toString() {
        return this.getKey()+"-"+this.getValue();
    }
}

public class CustomEnumDemo {

    @Test
    public void test(){
        System.out.println("获取key值为1的枚举对应的value:"+CustomEnum.getValueByKey(1));
        System.out.println("打印MOON枚举实例内容:"+CustomEnum.MOON);
        CustomEnum.MOON.setValue("MOD MOON");
        System.out.println("修改后的MOON枚举实例内容:"+CustomEnum.MOON);
    }
}


# 响应结果
获取key值为1的枚举对应的value:MORNING
打印MOON枚举实例内容:2-MOON
修改后的MOON枚举实例内容:2-MOD MOON 

🔖应用4：枚举实现接口概念

public interface Behaviour { 
    void print(); 
    String getInfo(); 
} 
public enum Color implements Behaviour{ 
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); 
    // 成员变量 
    private String name; 
    private int index; 
    // 构造方法 
    private Color(String name, int index) { 
        this.name = name; this.index = index; 
    } 
    // 接口方法实现
    @Override 
    public String getInfo() { 
        return this.name; 
    } 
    // 接口方法实现
    @Override 
    public void print() { 
        System.out.println(this.index+":"+this.name); 
    } 
}

🔖应用5：接口组织枚举

public interface Food { 
    enum Coffee implements Food{ 
        BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO 
    } 
    enum Dessert implements Food{ 
        FRUIT, CAKE, GELATO 
    } 
}

🔖应用6：动态增加枚举实例概念

​ 结合实际场景应用引入动态增加枚举实例概念

<3>扩展内容

🔖枚举类的比较

​ 查看Enum枚举类的源码实现可知，equals方法里面用==进行比较，因此用直接==和equals执行效果一致

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable{
    ...... 
  public final boolean equals(Object other) {
        return this==other;
  }
    ......
}

​ 测试案例参考：

// 在上述案例基础上编写测试方法
	@Test
    public void testCompare(){
        CustomEnum moon1 = CustomEnum.MOON;
        CustomEnum moon2 = CustomEnum.MOON;
        CustomEnum evening = CustomEnum.EVENING;
        System.out.println("moon1-moon2比较==:"+(moon1==moon2));
        System.out.println("moon1-moon2比较equals:"+(moon1.equals(moon2)));
        System.out.println("moon1-evening比较==:"+(moon1==evening));
        System.out.println("moon1-evening比较equals:"+(moon1.equals(evening)));
    }

# 响应结果
moon1-moon2比较==:true
moon1-moon2比较equals:true
moon1-evening比较==:false
moon1-evening比较equals:false

🔖枚举遍历

import java.util.Arrays;

/**
 * 枚举遍历说明
 */

enum AlarmGrade {

    ATTENTION("attention", "提示"),
    WARNING("warning","警告"),
    SERIOUS("serious", "严重"),
    FAULT("fault", "故障"),
    UNKNOWN("unknown", "未知");

    private String key;

    private String name;

    // 构造器
    AlarmGrade(String key, String name) {
        this.key = key;
        this.name = name;
    }

    // get、set构造器
    public String getKey() {
        return key;
    }

    public String getName() {
        return name;
    }


    /**
     * a.普通for循环遍历，比较判断
     */
    public static AlarmGrade getEnumType(String key) {
        AlarmGrade[] alarmGrades = AlarmGrade.values();
        for (int i = 0; i < alarmGrades.length; i++) {
            if (alarmGrades[i].getKey().equals(key)) {
                return alarmGrades[i];
            }
        }
        return AlarmGrade.UNKNOWN;
    }

    /**
     * b.增强for循环遍历，比较判断
     */
    public static AlarmGrade getEnumType1(String key) {
        AlarmGrade[] alarmGrades = AlarmGrade.values();
        for (AlarmGrade alarmGrade : alarmGrades) {
            if (alarmGrade.getKey().equals(key)) {
                return alarmGrade;
            }
        }
        return AlarmGrade.UNKNOWN;
    }

    /**
     * c.Lambda表达式，比较判断（JDK 1.8）
     */
    public static AlarmGrade getEnumType2(String key) {
        AlarmGrade[] alarmGrades = AlarmGrade.values();
        AlarmGrade result = Arrays.asList(alarmGrades).stream()
                .filter(alarmGrade -> alarmGrade.getKey().equals(key))
                .findFirst().orElse(AlarmGrade.UNKNOWN);

        return result;
    }

    /**
     * d.Lambda表达式，比较判断（JDK 1.8）
     */
    public static AlarmGrade getEnumType3(String key) {
        return Arrays.asList(AlarmGrade.values()).stream()
                .filter(alarmGrade -> alarmGrade.getKey().equals(key))
                .findFirst().orElse(AlarmGrade.UNKNOWN);
    }


}

public class EnumTraversalDemo {

    public static void main(String[] args) {

        // 根据Key得到枚举的Value,遍历参考,比较判断
        String grade = "attention";
        System.out.println("a.普通for循环遍历 \n" + grade + ": " + AlarmGrade.getEnumType(grade).getName());
        System.out.println("\nb.增强for循环遍历 \n" + grade + ": " + AlarmGrade.getEnumType1(grade).getName());
        System.out.println("\nc.Lambda表达式 \n" + grade + ": " + AlarmGrade.getEnumType2(grade).getName());
        System.out.println("\nd.Lambda表达式 \n" + grade + ": " + AlarmGrade.getEnumType3(grade).getName());
    }

}

🔖实际业务场景参考

​ 结合上述枚举应用进行扩展，参考实际业务场景：有时候为了避免多个enum文件定义代码管理混乱，可以考虑将某种业务类型的枚举统一在一个enum文件中进行定义，可根据自定义业务类型区分

​ 例如某个业务模块场景中，需要有针对多个不同字段的枚举说明，每个字段定义难免出现冲突的key情况，可额外扩展自定义字段enumType，由enumType+key唯一限定相应的枚举实例，参考如下设计（可结合自定义需求进行扩展）

​ 或者是在一个enum文件中拆分不同集合用于存储不同类型的枚举实例，随后提供不同的方法返回相应的数据

import org.apache.commons.lang3.StringUtils;

/**
 * 自定义枚举类型映射常量集合
 */
class EnumTypeConst {

    public static String MODE = "MODE";

    public static String DEL_TAG = "DEL_TAG";

}

public enum BusinessEnum {

    /** 模式相关枚举定义 **/
    MODE_PRIMARY(EnumTypeConst.MODE,"01","首选模式"),
    MODE_SECONDARY(EnumTypeConst.MODE,"02","备选模式"),
    MODE_EXTEND(EnumTypeConst.MODE,"03","扩展模式"),

    /** 删除标识相关枚举定义 **/
    DEL_TAG_NO(EnumTypeConst.DEL_TAG,"0","保存状态"),
    DEL_TAG_YES(EnumTypeConst.DEL_TAG,"1","删除状态"),

    ;

    // 枚举类型enumType相同标明是同一个字段的枚举说明
    private String enumType;
    private String key;
    private String value;

    BusinessEnum(String enumType,String key, String value) {
        this.enumType = enumType;
        this.key = key;
        this.value = value;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String getEnumType() {
        return enumType;
    }

    public void setEnumType(String enumType) {
        this.enumType = enumType;
    }

    /**
     * 根据唯一标识限定值：enumType、key
     * */
    public static String getValueByUniqueKey(String enumType,String key){
        for (BusinessEnum enumData : BusinessEnum.values()) {
            if (StringUtils.equals(enumType, enumData.getEnumType()) && StringUtils.equals(key, enumData.getKey())) {
                return enumData.getValue();
            }
        }
        return null;
    }

}

# 额外参考:拆分集合存储不同类型的枚举实例
    // 限定在指定集合中返回相关的枚举
     public static String getValueByKey(String key,List<FormResEnum> enumList){
        for (BusinessEnum enumData : enumList) {
            if (StringUtils.equals(key, enumData.getKey())) {
                return enumData.getValue();
            }
        }
        return null;
    }
    // XXX枚举转化
    public static String getValueByTargetEnumType(String key) {
        List<BusinessEnum> enumList = new ArrayList<>();
        enumList.add(XXX_A);
        enumList.add(XXX_B);
        enumList.add(XXX_C);
        enumList.add(XXX_D);
        return getValueByKey(key,enumList);
    }

集合相关遍历说明

Array、List、Map遍历

package com.oho.base.traversal;

import org.junit.Test;

import java.util.*;

public class TraversalDemo {

    /**
     * 1.Array遍历
     */
    @Test
    public void testArrayTraversal(){

        Integer[] items = {1, 2, 3};
        // a.普通for循环遍历
        for (int i = 0; i < items.length; i++) {
            System.out.println(items[i]);
        }

        // b.增强for循环遍历
        for (Integer item : items) {
            System.out.println(item);
        }

        // c.Lambda 表达式遍历（JDK 1.8）
        Arrays.asList(items).forEach(item -> System.out.println(item));

        // d.Lambda 表达式遍历（JDK 1.8）(简化Lambda表达式)
        Arrays.asList(items).forEach(System.out::println);
    }

    /**
     * 2.List遍历
     */
    @Test
    public void testListTraversal(){
        List<String> items = new ArrayList<>();
        items.add("A");
        items.add("B");
        items.add("C");

        // a.普通for循环遍历
        for (int i = 0; i < items.size(); i++) {
            System.out.println(items.get(i));
        }

        // b.增强for循环遍历
        for (String item : items) {
            System.out.println(item);
        }

        // c.Lambda 表达式遍历（JDK 1.8）
        items.forEach(item->{
            System.out.println(item);
        });

        // d.Lambda 表达式遍历（JDK 1.8）
        items.forEach(System.out::println);

        // 循环遍历的过程中可校验参数,除却上述循环中加入校验,还可通过下述方式实现（JDK 1.8）
        items.stream().filter(s->s.equals("C")).forEach(System.out::println);

    }

    /**
     * 3.Map遍历
     */
    @Test
    public void testMapTraversal(){
        Map<String, String> map = new HashMap<String, String>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        // a.借助Map的keySet遍历key、value值
        for (String key : map.keySet()) {
            System.out.println("Key: " + key + ", Value: " + map.get(key));
        }

        // b.迭代器遍历(适用于在遍历过程中，有删除某些Key-Value的需求的场景)
        System.out.println("\n第二种遍历方式：通过Iterator 迭代器遍历 Key 和 Value");
        Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext()) {
            Map.Entry<String, String> entry = iterator.next();
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // c.借助Map的entrySet遍历key、value值
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }

        // d.借助Map的value遍历value(该方式无法对应key)
        for (String value : map.values()) {
            System.out.println("Value: " + value);
        }

        // e.（JDK 1.8支持的 Lambda 表达式）
        map.forEach((key, value) -> {
            System.out.println("Key: " + key + ", Value: " + value);
        });

    }
}