JAVA反射获取所有枚举
 
定义枚举接口
枚举类
获取所有枚举
输出
 

 
定义枚举接口
 
public interface BaseEnum {
    /**
     * 获取枚举值
     * @returnint
     */
    Integer getValue();

    /**
     * 获取枚举名称
     * @return
     */
    String getName();
}
 
枚举类
 
@Getter
public enum TestEnum implements BaseEnum {
    TEST1("name1",1),
    TEST2("name1",2),
    TEST3("name1",3);

    private String name;
    private Integer value;

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

}
 
获取所有枚举
 
    public static void test4(){

        Reflections reflections = new Reflections("com.xxx.modules");

        Set<Class<? extends BaseEnum>> monitorClasses = reflections.getSubTypesOf(BaseEnum.class);

        System.out.println("size:"+monitorClasses.size());
        monitorClasses.forEach(m->{
            try {
                System.out.println("name:"+m.getSimpleName());
                BaseEnum[] enumConstants = m.getEnumConstants();

                for (BaseEnum anEnum : enumConstants) {
                    System.out.println("enumName:"+anEnum+"  value:"+anEnum.getValue()+"  name:"+anEnum.getName());
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
 
输出
 

定义枚举接口
 
public interface BaseEnum {
    /**
     * 获取枚举值
     * @returnint
     */
    Integer getValue();

    /**
     * 获取枚举名称
     * @return
     */
    String getName();
}
 
枚举类
 
@Getter
public enum TestEnum implements BaseEnum {
    TEST1("name1",1),
    TEST2("name1",2),
    TEST3("name1",3);

    private String name;
    private Integer value;

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

}
 
获取所有枚举
 
    public static void test4(){

        Reflections reflections = new Reflections("com.xxx.modules");

        Set<Class<? extends BaseEnum>> monitorClasses = reflections.getSubTypesOf(BaseEnum.class);

        System.out.println("size:"+monitorClasses.size());
        monitorClasses.forEach(m->{
            try {
                System.out.println("name:"+m.getSimpleName());
                BaseEnum[] enumConstants = m.getEnumConstants();

                for (BaseEnum anEnum : enumConstants) {
                    System.out.println("enumName:"+anEnum+"  value:"+anEnum.getValue()+"  name:"+anEnum.getName());
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
 
输出
 

 
先说下枚举类的结构：枚举类中有许多枚举常量，枚举常量由枚举类中各个字段组成，更确切的说，枚举常量由构造方法入参字段构成。
 
所以如果要获取枚举常量中的值，首先需要使用class的getEnumConstants()方法获取枚举类中所有的枚举常量，然后使用类中对应的方法，得到常量中包含字段的值。代码如下：
 
1.枚举类代码示例
 
package com.ecarx.jsk.jdk.poi;
 
public enum ResultCode {
 
CODE_5200("8200", "认证失败"),
 
CODE_5201("8201", "用户不存在"),
 
CODE_5202("8202", "Token验证失败"),
 
CODE_5203("8203", "Token刷新失败");
 
private String code;
 
private String name;
 
private ResultCode(String code, String name) {
 
this.code = code;
 
this.name = name;
 
}
 
public String getCode() {
 
return this.code;
 
}
 
public void setCode(String code) {
 
this.code = code;
 
}
 
public String getName() {
 
return this.name;
 
}
 
public void setName(String name) {
 
this.name = name;
 
}
 
}2.利用反射获取枚举值代码
 
@Test
 
public void getEnumValue() throws Exception {
 
// 1.得到枚举类对象
 
Class> clz = ResultCode.class;
 
// 2.得到所有枚举常量
 
Object[] objects = clz.getEnumConstants();
 
Method getCode = clz.getMethod("getCode");
 
Method getName = clz.getMethod("getName");
 
for (Object obj : objects){
 
// 3.调用对应方法，得到枚举常量中字段的值
 
System.out.println("code=" + getCode.invoke(obj) + "; name=" + getName.invoke(obj));
 
}
 
}
 
3.输出结果
 

场景：
 
在开发过程中，经常会遇到需要根据枚举的code获取对应name或根据name获取对应code的需求；抑或是需要根据code或name获取对应枚举对象。
 在开发过程中，前端需要获取下拉选择器中的数据项，通常存放数据库字典表中，本文采取返回枚举列表的方式提供。
 
一、Enum根据code/name获取枚举对象、根据code获取name、根据name获取code。
 
    @Getter
    @AllArgsConstructor
    public enum BorrowStatusEnum {
        /**
         * 借基差还款状态
         */
        IN_USE("IN_USE", "使用中"),
        OVERDUE("OVERDUE", "已超期"),
        DEDUCTION("DEDUCTION", "抵扣中"),
        FINISH("FINISH", "已还款");
        /**
         * 状态
         */
        public final String code;
        /**
         * 名称
         */
        public final String name;

        /**
         * 根据code查找
         * @param code 枚举code
         * @return 枚举对象
         */
        public static BorrowStatusEnum findEnumByCode(String code) {
            for (BorrowStatusEnum statusEnum : BorrowStatusEnum.values()) {
                if (statusEnum.getCode().equals(code)) {
                    //如果需要直接返回name则更改返回类型为String,return statusEnum.name;
                    return statusEnum;
                }
            }
            throw new IllegalArgumentException("code is invalid");
        }

        /**
         * 根据name查找
         * @param name 枚举name
         * @return 枚举对象
         */
        public static BorrowStatusEnum findEnumByName(String name) {
            for (BorrowStatusEnum statusEnum : BorrowStatusEnum.values()) {
                if (statusEnum.getName().equals(name)) {
                    //如果需要直接返回code则更改返回类型为String,return statusEnum.code;
                    return statusEnum;
                }
            }
            throw new IllegalArgumentException("name is invalid");
        }

    }
 
测试：
 
    public static void main(String[] args) {
        System.out.println("根据code获取枚举对象:" + BorrowStatusEnum.findEnumByCode("IN_USE"));
        System.out.println("根据name获取枚举对象:" + BorrowStatusEnum.findEnumByName("已还款"));
        
        System.out.println("根据code获取name:" + BorrowStatusEnum.findEnumByCode("IN_USE").name);
        System.out.println("根据name获取code:" + BorrowStatusEnum.findEnumByName("已还款").code);
    }
 
输出：
 
根据code获取枚举对象:IN_USE
根据name获取枚举对象:FINISH
根据code获取name:使用中
根据name获取code:FINISH
 
二、获取Enum列表
 
@Getter
    @AllArgsConstructor
    public enum BorrowStatusEnum {
        /**
         * 借基差还款状态
         */
        IN_USE("IN_USE", "使用中"),
        OVERDUE("OVERDUE", "已超期"),
        DEDUCTION("DEDUCTION", "抵扣中"),
        FINISH("FINISH", "已还款");
        /**
         * 状态
         */
        public final String code;
        /**
         * 名称
         */
        public final String name;

        /**
         * 转为数据
         * @return 枚举对象数组
         */
        public static List<Map<String, String>> toList() {
            List<Map<String, String>> list = new ArrayList<>();
            for (BorrowStatusEnum item : BorrowStatusEnum.values()) {
                Map<String, String> map = new HashMap<>();
                map.put("code", item.getCode());
                map.put("name", item.getName());
                list.add(map);
            }
            return list;
        }

    }
 
测试：
 
    public static void main(String[] args) {
        System.out.println("enum toString:" + BorrowStatusEnum.toList());
    }
 
输出：
 
enum toString:[{code=IN_USE, name=使用中}, {code=OVERDUE, name=已超期}, {code=DEDUCTION, name=抵扣中}, {code=FINISH, name=已还款}]
 
三、附上获取Enum列表工具类（使用工具类就不需要每个Enum都加一遍toList方法了！）
 
public class EnumUtils {

    private static final String ENUM_CLASSPATH ="java.lang.Enum";

    public static List<Map<String, Object>> enumToListMap(Class<?> enumClass) {
        List<Map<String, Object>> resultList= new ArrayList<>();
        if (!ENUM_CLASSPATH.equals(enumClass.getSuperclass().getCanonicalName())) {
            return resultList;
        }
        // 获取所有public方法
        Method[] methods = enumClass.getMethods();
        List<Field> fieldList = new ArrayList<>();
        //1.通过get方法提取字段，避免get作为自定义方法的开头，建议使用 ‘find’或其余命名
        Arrays.stream(methods)
                .map(Method::getName)
                .filter(
                        methodName -> methodName.startsWith("get") && !"getDeclaringClass".equals(methodName) && !"getClass".equals(methodName)
                ).forEachOrdered(methodName -> {
            try {
                Field field = enumClass.getDeclaredField(StringUtils.uncapitalize(methodName.substring(3)));
                fieldList.add(field);
            } catch (NoSuchFieldException | SecurityException e) {
                e.printStackTrace();
            }
        });
 
        //2.将字段作为key，逐一把枚举值作为value 存入list
        if (CollectionUtils.isEmpty(fieldList)) {
            return resultList;
        }
 
        Enum[] enums = (Enum[]) enumClass.getEnumConstants();
        for (Enum anEnum : enums) {
            Map<String, Object> map = new HashMap<>(fieldList.size());
            for (Field field : fieldList) {
                field.setAccessible(true);
                try {
                    // 向map集合添加字段名称 和 字段值
                    map.put(field.getName(), field.get(anEnum));
                } catch (IllegalArgumentException | IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            // 将Map添加到集合中
            resultList.add(map);
        }
        return resultList;
    }
 
}
 
测试：
 
    public static void main(String[] args) {
        //调用时需传入枚举类.class
        System.out.println("EnumUtils.enumToListMap:" + EnumUtils.enumToListMap(StatusEnum.BorrowStatusEnum.class));
    }
 
输出：
 
EnumUtils.enumToListMap:[{name=使用中, code=IN_USE}, {name=已超期, code=OVERDUE}, {name=抵扣中, code=DEDUCTION}, {name=已还款, code=FINISH}]
 
工具类参考博客：https://blog.csdn.net/qq_35387940/article/details/113772411