java 枚举 获取key java枚举获取对应值

目录

• 一. 一个参数
• 二. 两个参数
• 三. 接口聚合多个枚举类
• 四. 枚举类初始化Map与List

---

一. 一个参数

// 性别枚举类
public enum SexTypes {

    男性("1"),
    女性("2");
    
    private String code;

    SexTypes(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    // 根据code获取枚举类对象,例如根据1获取男性枚举类对象;根据2获取女性枚举类对象
    public static SexTypes fromCode(String code) {

        return Arrays.stream(SexTypes.values())
                .filter(item -> item.code.equals(code))
                .findAny()
                .orElse(null);
    }
    
    // 根据汉字类获取枚举类对应,例如根据男性获取男性枚举类对象;根据女性获取女性枚举类对象
    public static SexTypes fromName(String name) {

        return Arrays.stream(SexTypes.values())
                .filter(item -> item.name().equals(name))
                .findAny()
                .orElse(null);
    }
}

// 使用(通过枚举类来将汉字翻译为code)
Strnig sexType = "男性";
SexTypes fromNameSex = SexTypes.fromName(sexType);
// 通过枚举类对象获取code
Strnig code = fromNameSex.getCode();
// 通过枚举类对象获取枚举类名称
String name = fromNameSex.name();

---

二. 两个参数

// 依赖内容枚举类
public enum IrainaiyouTypes {

    依頼1(new BigDecimal(1), 2),
    依頼2(new BigDecimal(2), 2),
    依頼3(new BigDecimal(3), 10),
    依頼4(new BigDecimal(4), 10),
    依頼5(new BigDecimal(5), 4),
    依頼6(new BigDecimal(6), 2),
    依頼7(new BigDecimal(7), 1);

    // code
    private BigDecimal code;
    // 通知者人数
    private int tuchiNinzu;

    // 构造方法
    IrainaiyouTypes(BigDecimal code, int tuchiNinzu) {
        this.code = code;
        this.tuchiNinzu = tuchiNinzu;
    }

    public BigDecimal getCode() {
        return code;
    }

    public int getTuchiNinzu() {
        return tuchiNinzu;
    }

    public static IrainaiyouTypes fromCode(BigDecimal code) {

        for (IrainaiyouTypes item : IrainaiyouTypes.values()) {
            if (item.code.equals(code)) {
                return item;
            }
        }
        return null;
    }
}

// 使用(可以不直接硬编码code,而是通过汉字这种有语义的方式获取,增加了可读性)
BigDecimal code = IrainaiyouTypes.依頼1.getCode();
int tuchiNinzu = IrainaiyouTypes.依頼1.getTuchiNinzu();

---

三. 接口聚合多个枚举类

import java.util.Arrays;

// 枚举类的聚合接口
public interface AggregationEnum {
	
	String getCode();
	
	// ⏹咖啡枚举类
	enum Coffee implements AggregationEnum {
		
		黑咖啡,
		低卡咖啡,
		拿铁,
		卡布奇诺;

		@Override
		public String getCode() {
			return null;
		}
	}
	
	// ⏹性别枚举类
	enum SEX implements AggregationEnum {
		
		男("1"),
		女("2");
		
		String code; 

		SEX(String code) {
			this.code = code;
		}
		
		@Override
		public String getCode() {
			return code;
		}
		
		// 根据code获取枚举类对象
		public static SEX fromCode(String code) {
			return Arrays.stream(SEX.values())
						.filter(item -> item.code.equals(code))
						.findAny()
						.orElse(null);
		}
		
		// 根据名称获取枚举类对象
		public static SEX fromName(String name) {
			return Arrays.stream(SEX.values())
						.filter(item -> item.name().equals(name))
						.findAny()
						.orElse(null);
		}
	}
}

⏹ 使用

// 使用接口聚合枚举类
Coffee[] coffees = AggregationEnum.Coffee.values();
Arrays.stream(coffees).forEach(item -> {
	System.out.println(item.name());
});
System.out.println("=== === ===");

SEX[] sexs = AggregationEnum.SEX.values();
Arrays.stream(sexs).forEach(item -> {
	System.out.println("名称为: " + item.name() + ", code为: "+ item.getCode());
});
/*
	BLACK_COFFEE
	DECAF_COFFEE
	LATTE
	CAPPUCCINO
	=== === ===
	名称为: 男, code为: 1
	名称为: 女, code为: 2
*/

四. 枚举类初始化Map与List

⏹枚举类接口

public interface EnumValueName {

    Integer getValue();

    String getName();
}

⏹属性中包含List与Map的枚举类

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public enum GenderEnum implements EnumValueName {

    MALE(1, "男"),
    FEMALE(0, "女");

    // 性别值数组
    public static final List<Integer> genderValueList = Arrays.stream(values()).map(GenderEnum::getValue).collect(Collectors.toList());

    // 性别名数组
    public static final List<String> genderNameList = Arrays.stream(values()).map(GenderEnum::getName).collect(Collectors.toList());

    // 性别值与性别名Map
    public static final Map<Integer, String> genderValNameMap = Arrays.stream(values()).collect(
            Collectors.toMap(
                GenderEnum::getValue,
                GenderEnum::getName
            )
    );

    // 性别名与性别值Map
    public static final Map<String, Integer> genderNameValMap = Arrays.stream(values()).collect(
            Collectors.toMap(
                GenderEnum::getName,
                GenderEnum::getValue
            )
    );

    // 性别值
    private final Integer value;

    // 性别名
    private final String name;

    GenderEnum(Integer value, String name) {
        this.value = value;
        this.name = name;
    }

    @Override
    public Integer getValue() {
        return value;
    }

    @Override
    public String getName() {
        return name;
    }
}

⏹使用

// 获取性别枚举类总的所有性别名称List
List<String> genderNameList = GenderEnum.genderNameList;
System.out.println(genderNameList);  // [男, 女]

// 获取性别枚举类总的所有性别值List
List<Integer> genderValueList = GenderEnum.genderValueList;
System.out.println(genderValueList);  // [1, 0]

// 获取性别枚举类总的所有性别值与性别名Map
Map<Integer, String> genderValNameMap = GenderEnum.genderValNameMap;
System.out.println(genderValNameMap);  // {0=女, 1=男}

// 获取性别枚举类总的所有性别名与性别值Map
Map<String, Integer> genderNameValMap = GenderEnum.genderNameValMap;
System.out.println(genderNameValMap);  // {女=0, 男=1}

// 获取所有的枚举类对象
GenderEnum[] genderEnums = GenderEnum.values(); 
// ※打印的是枚举类对象
System.out.println(Arrays.toString(genderEnums));  // [MALE, FEMALE]