总结：Java枚举类Enum常用API，与EnumUtil工具类封装

一·通过enum关键字创建一个枚举类：

public enum UserStatus {
    /**
     * 正常
     */
    Normal(1, "正常"),
    Locked(2, "锁定"),
    Delete(3, "删除"),
    Disabled(4, "禁用"),
    NotCertified(5, "未认证");

    private Integer code;
    private String description;

    UserStatus(Integer code, String description) {
        this.code = code;
        this.description = description;
    }

    public Integer getCode() {
        return code;
    }

    public String getDescription() {
        return description;
    }
}

二·自定义枚举对象常用方法示例：

1.获取枚举值方法：一般为code字段

//获取code值：4
Integer code = UserStatus.Disabled.getCode();
System.out.println(code);

2.获取描述值方法：一般为description字段

//获取description值：禁用
String description = UserStatus.Disabled.getDescription();
System.out.println(description);

3.获取枚举对象名称：

//获取枚举对象在枚举类中的名称：Disabled
String name = UserStatus.Disabled.name();
System.out.println(name);

4.获取枚举对象在枚举类中的索引位置：从0开始计算

//获取枚举对象在枚举类中的索引位置，从0开始计算，即ordinal值：3
int ordinal = UserStatus.Disabled.ordinal();
System.out.println(ordinal);

5.获取枚举对象的序列化方法：一般很少用

//获取枚举类中所有的枚举对象：Optional[EnumDesc[UserStatus.Disabled]]
Optional<Enum.EnumDesc<UserStatus>> userStatusEnumDesc = UserStatus.Disabled.describeConstable();
System.out.println(userStatusEnumDesc);

6.获取枚举类的class对象：

//获取枚举类对象的class对象：true
Class<UserStatus> declaringClass = UserStatus.Disabled.getDeclaringClass();
Class<? extends UserStatus> aClass = UserStatus.Disabled.getClass();
System.out.println(declaringClass == aClass);

三·自定义枚举类，自带静态方法常用示例：

1.获取枚举单个对象：

//获取枚举单个对象：Locked
UserStatus locked = UserStatus.Locked;
System.out.println(locked);

2.根据枚举对象名，获取对应的枚举对象，方式一：

//根据枚举对象名，获取对应的枚举对象，方式一：Normal
UserStatus normal = UserStatus.valueOf("Normal");
System.out.println(normal);

3.根据枚举对象名，获取对应的枚举对象，方式二：

//根据枚举对象名，获取对应的枚举对象，方式二：Delete
UserStatus delete = UserStatus.valueOf(UserStatus.class, "Delete");
System.out.println(delete);

4.获取枚举类中全部枚举对象数组集合：

//获取所有枚举对象数组集合
UserStatus[] values = UserStatus.values();
System.out.println(Arrays.toString(values));

四·枚举类Class对象常用方法示例：这块不仅包含枚举相关的API，也涉及class的反射内容方法API

1.获取该类型的全类名：

//获取该类型的全类名：com.pazl.iot.admin.bean.UserStatus
String typeName = UserStatus.class.getTypeName();
System.out.println(typeName);

2.判断该类是不是枚举类型：

//判断该类是不是枚举类型：true
boolean anEnum = UserStatus.class.isEnum();
System.out.println(anEnum);

3.获取枚举对象数组集合：

//获取枚举对象数组集合：如果是非枚举类class调用，则直接返回null
UserStatus[] enumConstants = UserStatus.class.getEnumConstants();
for (UserStatus enumConstant : enumConstants) {
    //输出每个枚举对象的code和description
    System.out.println(enumConstant.getCode() + "：" + enumConstant.getDescription());
}

4.获取该类声明的所有属性字段：

//获取该类声明的所有属性字段
Field[] declaredFields = UserStatus.class.getDeclaredFields();
for (Field declaredField : declaredFields) {
    //输出每个属性字段
    System.out.println(declaredField);
}

五·枚举类父类，Enum常用方法示例：

1.根据枚举对象名，获取对应的枚举对象，方式三：

//根据枚举对象名，获取对应的枚举对象，方式三
UserStatus normal_1 = Enum.valueOf(UserStatus.class, "Normal");
System.out.println(normal_1);

六·EnumUtil工具类封装：各种枚举类本身不具备，但是开发中经常需要使用的功能方法

import com.alibaba.fastjson2.JSON;
import com.pazl.iot.admin.bean.UserStatus;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;

/**
 * 枚举工具类
 *
 * @author LiuMingFu
 * @date 2024/3/9
 */
public class EnumUtils {
    
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        System.out.println("1.======================================================================================================");

        /**
         * 1.枚举类单个对象常用方法示例：
         */
        //获取code值：4
        Integer code = UserStatus.Disabled.getCode();
        System.out.println(code);

        //获取description值：禁用
        String description = UserStatus.Disabled.getDescription();
        System.out.println(description);

        //获取枚举对象在枚举类中的名称：Disabled
        String name = UserStatus.Disabled.name();
        System.out.println(name);

        //获取枚举对象在枚举类中的索引位置，从0开始计算，即ordinal值：3
        int ordinal = UserStatus.Disabled.ordinal();
        System.out.println(ordinal);

        //获取枚举类中所有的枚举对象：Optional[EnumDesc[UserStatus.Disabled]]
        Optional<Enum.EnumDesc<UserStatus>> userStatusEnumDesc = UserStatus.Disabled.describeConstable();
        System.out.println(userStatusEnumDesc);

        //获取枚举类对象的class对象：true
        Class<UserStatus> declaringClass = UserStatus.Disabled.getDeclaringClass();
        Class<? extends UserStatus> aClass = UserStatus.Disabled.getClass();
        System.out.println(declaringClass == aClass);

        System.out.println("2.======================================================================================================");

        /**
         * 2.枚举类自带静态常用方法示例：
         */
        //获取枚举单个对象：Locked
        UserStatus locked = UserStatus.Locked;
        System.out.println(locked);

        //根据枚举对象名，获取对应的枚举对象，方式一：Normal
        UserStatus normal = UserStatus.valueOf("Normal");
        System.out.println(normal);

        //根据枚举对象名，获取对应的枚举对象，方式二：Delete
        UserStatus delete = UserStatus.valueOf(UserStatus.class, "Delete");
        System.out.println(delete);

        //获取所有枚举对象数组集合
        UserStatus[] values = UserStatus.values();
        System.out.println(Arrays.toString(values));

        System.out.println("3.======================================================================================================");


        /**
         * 3.枚举类class对象常用方法示例：这块也涉及class的反射内容方法API
         */
        //获取该类型的全类名：com.pazl.iot.admin.bean.UserStatus
        String typeName = UserStatus.class.getTypeName();
        System.out.println(typeName);

        //判断该类是不是枚举类型：true
        boolean anEnum = UserStatus.class.isEnum();
        System.out.println(anEnum);

        //获取枚举对象数组集合：如果是非枚举类class调用，则直接返回null
        UserStatus[] enumConstants = UserStatus.class.getEnumConstants();
        for (UserStatus enumConstant : enumConstants) {
            //输出每个枚举对象的code和description
            System.out.println(enumConstant.getCode() + "：" + enumConstant.getDescription());
        }

        //获取该类声明的所有属性字段
        Field[] declaredFields = UserStatus.class.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            //输出每个属性字段
            System.out.println(declaredField);
        }

        System.out.println("4.======================================================================================================");


        /**
         * 4.所有枚举类父类，Enum常用方法示例：
         */
        //根据枚举对象名，获取对应的枚举对象，方式三
        UserStatus normal_1 = Enum.valueOf(UserStatus.class, "Normal");
        System.out.println(normal_1);

        System.out.println("5.======================================================================================================");
        //根据枚举类code值，获取对应的枚举类对象
        UserStatus enumObject = getEnumObjectByCode(UserStatus.class, 3);
        System.out.println(enumObject.getCode());
        System.out.println(enumObject.getDescription());

        UserStatus enumObject2 = getEnumObjectByDescription(UserStatus.class, "未认证");
        System.out.println(enumObject2.getCode());
        System.out.println(enumObject2.getDescription());

        UserStatus enumObject3 = getEnumObject(UserStatus.class, "description", "未认证");
        System.out.println(enumObject3.getCode());
        System.out.println(enumObject3.getDescription());

        UserStatus enumObject4 = getEnumObject(UserStatus.class, "code", 3);
        System.out.println(enumObject4.getCode());
        System.out.println(enumObject4.getDescription());


        Map<String, String> enumMapWithStringKey = getEnumMapWithStringKey(UserStatus.class);
        //转为json打印输出，需要引入外包fastjson依赖包，不需要去掉就行
        System.out.println(JSON.toJSONString(enumMapWithStringKey));
        Map<String, String> enumMapWithStringKey2 = getEnumMapWithStringKey(UserStatus.Delete);
        System.out.println(JSON.toJSONString(enumMapWithStringKey2));

        Map<Integer, String> enumMapWithIntegerKey = getEnumMapWithIntegerKey(UserStatus.class);
        System.out.println(JSON.toJSONString(enumMapWithIntegerKey));
        Map<Integer, String> enumMapWithIntegerKey2 = getEnumMapWithIntegerKey(UserStatus.Delete);
        System.out.println(JSON.toJSONString(enumMapWithIntegerKey2));

    }


    /**
     * 根据枚举类整型字段的指定值、class对象，获取对应的枚举类对象
     *
     * @param enumClass         目标枚举类class对象
     * @param integerFieldName  枚举类存在的一个整型字段名
     * @param integerFieldValue 枚举类该整型字段的值
     * @param <T>               枚举类类型
     * @return
     * @author LiuMingFu
     * @date 2024/3/9
     */
    public static <T extends Enum<T>> T getEnumObject(Class<T> enumClass, String integerFieldName, Integer integerFieldValue) throws NoSuchFieldException, IllegalAccessException {
        //根据class对象，获取枚举类中名称为 integerFieldName 的属性字段对象
        Field integerField = enumClass.getDeclaredField(integerFieldName);
        //设置强制访问权限：一般情况私有属性、方法不允许反射访问
        integerField.setAccessible(true);

        //获取该枚举类声明的所有枚举对象
        T[] enumConstants = enumClass.getEnumConstants();
        for (T enumConstant : enumConstants) {
            //获取每个枚举对象的该属性值
            Integer value = (Integer) integerField.get(enumConstant);
            //若根据参数值一样，则将该枚举类对象直接返回
            if (integerFieldValue.equals(value)) {
                return enumConstant;
            }
        }

        //没有则返回null
        return null;
    }


    /**
     * 根据枚举类字符串类型字段的指定值、class对象，获取对应的枚举类对象
     *
     * @param enumClass        目标枚举类class对象
     * @param stringFieldName  枚举类存在的一个字符串类型字段名
     * @param stringFieldValue 枚举类该整型字符串类型的值
     * @param <T>              枚举类类型
     * @return
     * @author LiuMingFu
     * @date 2024/3/9
     */
    public static <T extends Enum<T>> T getEnumObject(Class<T> enumClass, String stringFieldName, String stringFieldValue) throws NoSuchFieldException, IllegalAccessException {
        //根据class对象，获取枚举类中名称为 stringFieldName 的属性字段对象
        Field stringField = enumClass.getDeclaredField(stringFieldName);
        //设置强制访问权限：一般情况私有属性、方法不允许反射访问
        stringField.setAccessible(true);

        //获取该枚举类声明的所有枚举对象
        T[] enumConstants = enumClass.getEnumConstants();
        for (T enumConstant : enumConstants) {
            //获取每个枚举对象的该属性值
            String value = (String) stringField.get(enumConstant);
            //若根据参数值一样，则将该枚举类对象直接返回
            if (stringFieldValue.equals(value)) {
                return enumConstant;
            }
        }

        //没有则返回null
        return null;
    }


    /**
     * 根据枚举对象的描述、class对象，获取对应的枚举类对象
     * 注意：需要该枚举类存在 description 字段才行
     *
     * @param enumClass   目标枚举类class对象
     * @param description 枚举对象的描述
     * @param <T>         枚举类类型
     * @return
     * @author LiuMingFu
     * @date 2024/3/9
     */
    public static <T extends Enum<T>> T getEnumObjectByDescription(Class<T> enumClass, String description) throws NoSuchFieldException, IllegalAccessException {
        //根据class对象，获取枚举类中名称为 description 的属性字段
        Field descField = enumClass.getDeclaredField("description");
        //设置强制访问权限：一般情况私有属性、方法不允许反射访问
        descField.setAccessible(true);

        //获取该枚举类声明的所有枚举对象
        T[] enumConstants = enumClass.getEnumConstants();
        for (T enumConstant : enumConstants) {
            //获取每个枚举对象的该属性值
            String descValue = (String) descField.get(enumConstant);
            //若根据参数值一样，则将该枚举类对象直接返回
            if (description.equals(descValue)) {
                return enumConstant;
            }
        }

        //没有则返回null
        return null;
    }


    /**
     * 根据枚举值、class对象，获取对应的枚举类对象
     * 注意：需要该枚举类存在 code 字段才行
     *
     * @param enumClass 目标枚举类class对象
     * @param code      枚举值
     * @param <T>       枚举类类型
     * @return
     * @author LiuMingFu
     * @date 2024/3/9
     */
    public static <T extends Enum<T>> T getEnumObjectByCode(Class<T> enumClass, Integer code) throws NoSuchFieldException, IllegalAccessException {
        //根据class对象，获取枚举类中名称为code的属性字段
        Field codeField = enumClass.getDeclaredField("code");
        //设置强制访问权限：一般情况私有属性、方法不允许反射访问
        codeField.setAccessible(true);

        //获取该枚举类声明的所有枚举对象
        T[] enumConstants = enumClass.getEnumConstants();
        for (T enumConstant : enumConstants) {
            //获取每个枚举对象的code属性值
            Integer codeValue = (Integer) codeField.get(enumConstant);
            //若根据参数值一样，则将该枚举类对象直接返回
            if (code.equals(codeValue)) {
                return enumConstant;
            }
        }

        //没有则返回null
        return null;
    }


    /**
     * 根据一个枚举类对象，获取他的枚举值
     * 注意：该枚举类必须存在 code 字段且为整型
     *
     * @param enumObject 一个枚举类对象
     * @return
     * @author LiuMingFu
     * @date 2024/3/9
     */
    public static <T extends Enum<T>> Integer getCode(T enumObject) throws IllegalAccessException, NoSuchFieldException {
        Field codeField = enumObject.getClass().getDeclaredField("code");
        codeField.setAccessible(true);
        return (Integer) codeField.get(enumObject);
    }


    /**
     * 根据一个枚举类对象，获取他的枚举值
     * 注意：该枚举类必须存在 codeFieldName 字段且为整型
     *
     * @param enumObject    一个枚举类对象
     * @param codeFieldName 枚举值字段名
     * @return
     * @author LiuMingFu
     * @date 2024/3/9
     */
    public static <T extends Enum<T>> Integer getCode(T enumObject, String codeFieldName) throws IllegalAccessException, NoSuchFieldException {
        Field codeField = enumObject.getClass().getDeclaredField(codeFieldName);
        codeField.setAccessible(true);
        return (Integer) codeField.get(enumObject);
    }


    /**
     * 根据一个枚举类对象，获取他的描述字符串
     * 注意：该枚举类必须存在 description 字段且为字符串类型
     *
     * @param enumObject 一个枚举类对象
     * @return
     * @author LiuMingFu
     * @date 2024/3/9
     */
    public static <T extends Enum<T>> String getDescription(T enumObject) throws IllegalAccessException, NoSuchFieldException {
        Field descriptionField = enumObject.getClass().getDeclaredField("description");
        descriptionField.setAccessible(true);
        return (String) descriptionField.get(enumObject);
    }


    /**
     * 根据一个枚举类对象，获取他的描述字符串
     * 注意：该枚举类必须存在 descFieldName 字段且为字符串类型
     *
     * @param enumObject    一个枚举类对象
     * @param descFieldName 枚举对象描述字段名
     * @return
     * @author LiuMingFu
     * @date 2024/3/9
     */
    public static <T extends Enum<T>> String getDescription(T enumObject, String descFieldName) throws IllegalAccessException, NoSuchFieldException {
        Field descriptionField = enumObject.getClass().getDeclaredField(descFieldName);
        descriptionField.setAccessible(true);
        return (String) descriptionField.get(enumObject);
    }


    /**
     * 获取枚举类中每个枚举值对应的map集合
     * key：枚举对象code值，
     * value：枚举对象description值
     *
     * @param enumClass 枚举类class对象
     * @param <T>       枚举类类型
     * @return
     * @author LiuMingFu
     * @date 2024/2/28
     */
    public static <T extends Enum<T>> Map<Integer, String> getEnumMapWithIntegerKey(Class<T> enumClass) throws NoSuchFieldException, IllegalAccessException {
        Map<Integer, String> enumMap = new LinkedHashMap<>();
        //获取所有枚举类属性字段
        Field[] fields = enumClass.getDeclaredFields();
        //循环处理各个枚举类型字段
        for (Field field : fields) {
            //判断是否为枚举属性字段
            if (field.isEnumConstant()) {
                //根据枚举类class对象、枚举字段名，获取对应的枚举类对象
                T enumValue = Enum.valueOf(enumClass, field.getName());
                //获取枚举对象code值
                Integer code = getCode(enumValue);
                //获取枚举对象描述
                String description = getDescription(enumValue);
                //放入map集合
                enumMap.put(code, description);
            }
        }

        return enumMap;
    }


    /**
     * 获取枚举类中每个枚举值对应的map集合
     * key：枚举对象code值，
     * value：枚举对象description值
     *
     * @param enumObject 一个枚举类对象
     * @param <T>        枚举类类型
     * @return
     * @author LiuMingFu
     * @date 2024/2/28
     */
    public static <T extends Enum<T>> Map<Integer, String> getEnumMapWithIntegerKey(T enumObject) throws NoSuchFieldException, IllegalAccessException {
        Map<Integer, String> enumMap = new LinkedHashMap<>();
        //获取所有枚举类属性字段
        Field[] fields = enumObject.getClass().getDeclaredFields();
        //循环处理各个枚举类型字段
        for (Field field : fields) {
            //判断是否为枚举属性字段
            if (field.isEnumConstant()) {
                //根据枚举类class对象、枚举字段名，获取对应的枚举类对象
                T enumValue = Enum.valueOf(enumObject.getDeclaringClass(), field.getName());
                //获取枚举对象code值
                Integer code = getCode(enumValue);
                //获取枚举对象描述
                String description = getDescription(enumValue);
                //放入map集合
                enumMap.put(code, description);
            }
        }

        return enumMap;
    }


    /**
     * 获取枚举类中每个枚举值对应的map集合
     * key：枚举对象code值，
     * value：枚举对象description值
     *
     * @param enumClass 枚举类class对象
     * @param <T>       枚举类类型
     * @return
     * @author LiuMingFu
     * @date 2024/2/28
     */
    public static <T extends Enum<T>> Map<String, String> getEnumMapWithStringKey(Class<T> enumClass) throws NoSuchFieldException, IllegalAccessException {
        Map<String, String> enumMap = new LinkedHashMap<>();
        //获取所有枚举类属性字段
        Field[] fields = enumClass.getDeclaredFields();
        //循环处理各个枚举类型字段
        for (Field field : fields) {
            //判断是否为枚举属性字段
            if (field.isEnumConstant()) {
                //根据枚举类class对象、枚举字段名，获取对应的枚举类对象
                T enumValue = Enum.valueOf(enumClass, field.getName());
                //获取枚举对象code值
                Integer code = getCode(enumValue);
                //获取枚举对象描述
                String description = getDescription(enumValue);
                //放入map集合
                enumMap.put(code.toString(), description);
            }
        }

        return enumMap;
    }


    /**
     * 获取枚举类中每个枚举值对应的map集合
     * key：枚举对象code值，
     * value：枚举对象description值
     *
     * @param enumObject 一个枚举类对象
     * @param <T>        枚举类类型
     * @return
     * @author LiuMingFu
     * @date 2024/2/28
     */
    public static <T extends Enum<T>> Map<String, String> getEnumMapWithStringKey(T enumObject) throws NoSuchFieldException, IllegalAccessException {
        Map<String, String> enumMap = new LinkedHashMap<>();
        //获取所有枚举类属性字段
        Field[] fields = enumObject.getClass().getDeclaredFields();
        //循环处理各个枚举类型字段
        for (Field field : fields) {
            //判断是否为枚举属性字段
            if (field.isEnumConstant()) {
                //根据枚举类class对象、枚举字段名，获取对应的枚举类对象
                T enumValue = Enum.valueOf(enumObject.getDeclaringClass(), field.getName());
                //获取枚举对象code值
                Integer code = getCode(enumValue);
                //获取枚举对象描述
                String description = getDescription(enumValue);
                //放入map集合
                enumMap.put(code.toString(), description);
            }
        }

        return enumMap;
    }

}