枚举 - Java枚举类优化 - 《Java 核心知识》

在我们的日常的开发中，枚举是无处不在的。比如我们使用到的各种状态各种类型都是需要使用枚举。也经常需要对枚举进行操作，例如根据将枚举的Value -> Name的操作（将枚举值转换为枚举的名称）。然而在我们的类中如果存在大量的枚举类，那么我们会乐此不疲的进行Ctrl +C -> Ctrl +V的操作。

@Getter
public enum EnumSubSceneType {
    /**
     * 逐业务改造
     */
    SERVICE("SERVICE"),
    /**
     * SRv6场景
     */
    SRV6("SRv6"),
    /**
     * IPv6场景
     */
    IPV6("IPv6");
    private String value;
    EnumSubSceneType(String value) {
        this.value = value;
    }
    /**
     * 根据子场景字符串获取子场景枚举
     *
     * @param subScene 子场景
     * @return 步骤名称
     */
    public static EnumSubSceneType getStepNameByNum(String subScene) {
        EnumSubSceneType[] enumTypes = values();
        for (EnumSubSceneType subTaskEnum : enumTypes) {
            if (subTaskEnum.getValue().equals(subScene)) {
                return subTaskEnum;
            }
        }
        return null;
    }
    /**
     * 获取枚举中的所有值
     *
     * @return 枚举中的所有值
     */
    public static List<String> getAllSubTaskType() {
        List<String> res = new ArrayList<>();
        EnumSubSceneType[] enumTypes = values();
        for (EnumSubSceneType subTaskEnum : enumTypes) {
            String s = subTaskEnum.getValue().toLowerCase(Locale.ENGLISH);
            res.add(s);
        }
        return res;
    }
}

那么我们是否有更好的方式来解决这一类的问题呢？做到代码的复用性搞，可扩展性强的优点呢？当然，Java是面向对象（面向接口编程）代码的复用性自然可以使用接口进行代替

/**
 * 功能描述 简单的枚举类，即只包含value(实现此接口可使用{@link EnumUtils}中的方法
 *
 * @author h00518386
 * @since 2022-02-28
 */
public interface ValueEnum<T> {
    /**
     * 获取枚举值
     *
     * @return 枚举值
     */
    T getValue();
}

扩展 ValueEnum 类。使得实现的枚举中即可拥有Name,也可以拥有Value

/**
 * 功能描述：带有枚举Name和Value的接口(实现此接口可使用{@link EnumUtils}中的方法
 *
 * @author h00518386
 * @since 2022-02-28
 */
public interface NameValueEnum<T> extends ValueEnum<T> {
    /**
     * 获取枚举名称
     * @return 枚举名
     */
    String getName();
}

把公共的代码进行抽取，使用泛型进行实现

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved.
 */
package com.huawei.enumdemo;
/**
 * 功能描述
 *
 * @author h00518386
 * @since 2022-02-28
 */
import org.springframework.util.StringUtils;
/**
 * 枚举常用工具类。<br/>
 * 使用该枚举工具类需要指定的枚举实现{@link ValueEnum} OR {@link NameValueEnum}接口
 *
 * @author meilin.huang
 * @version 1.0
 * @date 2019-03-22 11:12 AM
 */
public final class EnumUtils {
    /**
     * 判断枚举值是否存在于指定枚举数组中
     *
     * @param enums 枚举数组
     * @param value 枚举值
     * @return 是否存在
     */
    public static <T> boolean isExist(ValueEnum<T>[] enums, T value) {
        if (value == null) {
            return false;
        }
        for (ValueEnum<T> e : enums) {
            if (value.equals(e.getValue())) {
                return true;
            }
        }
        return false;
    }
    /**
     * 判断枚举值是否存与指定枚举类中
     *
     * @param enumClass 枚举类
     * @param value     枚举值
     * @param <E>       枚举类型
     * @param <V>       值类型
     * @return true：存在
     */
    @SuppressWarnings("unchecked")
    public static <E extends Enum<? extends ValueEnum<V>>, V> boolean isExist(Class<E> enumClass, V value) {
        for (Enum<? extends ValueEnum<V>> e : enumClass.getEnumConstants()) {
            if (((ValueEnum<V>) e).getValue().equals(value)) {
                return true;
            }
        }
        return false;
    }
    /**
     * 根据枚举值获取其对应的名字
     *
     * @param enums 枚举列表
     * @param value 枚举值
     * @return 枚举名称
     */
    public static <T> String getNameByValue(NameValueEnum<T>[] enums, T value) {
        if (value == null) {
            return null;
        }
        for (NameValueEnum<T> e : enums) {
            if (value.equals(e.getValue())) {
                return e.getName();
            }
        }
        return null;
    }
    /**
     * 根据枚举名称获取对应的枚举值
     *
     * @param enums 枚举列表
     * @param name  枚举名
     * @return 枚举值
     */
    public static <T> T getValueByName(NameValueEnum<T>[] enums, String name) {
        if (StringUtils.isEmpty(name)) {
            return null;
        }
        for (NameValueEnum<T> e : enums) {
            if (name.equals(e.getName())) {
                return e.getValue();
            }
        }
        return null;
    }
    /**
     * 根据枚举值获取对应的枚举对象
     *
     * @param enums 枚举列表
     * @return 枚举对象
     */
    @SuppressWarnings("unchecked")
    public static <E extends Enum<? extends ValueEnum<V>>, V> E getEnumByValue(E[] enums, V value) {
        for (E e : enums) {
            if (((ValueEnum<V>) e).getValue().equals(value)) {
                return e;
            }
        }
        return null;
    }
    /**
     * 根据枚举值获取对应的枚举对象
     *
     * @param enumClass 枚举class
     * @return 枚举对象
     */
    public static <E extends Enum<? extends ValueEnum<V>>, V> E getEnumByValue(Class<E> enumClass, V value) {
        return getEnumByValue(enumClass.getEnumConstants(), value);
    }
}

测试代码案例：

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved.
 */
import org.junit.Assert;
import org.junit.Test;
/**
 * 功能描述
 *
 * @author h00518386
 * @since 2022-02-28
 */
public class EnumUtilsTest {
    enum TestStrEnum implements NameValueEnum<String> {
        T1("01", "String类型测试1"),
        T2("02", "String类型测试2");
        private final String value;
        private final String name;
        TestStrEnum(String value, String name) {
            this.value = value;
            this.name = name;
        }
        @Override
        public String getName() {
            return this.name;
        }
        @Override
        public String getValue() {
            return this.value;
        }
    }
    enum TestIntEnum implements NameValueEnum<Integer> {
        T1(1, "Integer类型测试1"),
        T2(2, "Integer类型测试2");
        private final Integer value;
        private final String name;
        TestIntEnum(Integer value, String name) {
            this.value = value;
            this.name = name;
        }
        @Override
        public String getName() {
            return this.name;
        }
        @Override
        public Integer getValue() {
            return this.value;
        }
    }
    enum TestOnlyValueEnum implements ValueEnum<String> {
        T1("test1");
        private final String value;
        TestOnlyValueEnum(String value) {
            this.value = value;
        }
        @Override
        public String getValue() {
            return this.value;
        }
    }
    @Test
    public void isExist() {
        Assert.assertTrue(EnumUtils.isExist(TestStrEnum.values(), "01"));
        Assert.assertFalse(EnumUtils.isExist(TestStrEnum.values(), "03"));
        Assert.assertTrue(EnumUtils.isExist(TestIntEnum.values(), 2));
        Assert.assertFalse(EnumUtils.isExist(TestIntEnum.values(), 8));
    }
    @Test
    public void getNameByValue() {
        String name = EnumUtils.getNameByValue(TestStrEnum.values(), "01");
        String name2 = EnumUtils.getNameByValue(TestIntEnum.values(), 2);
        System.out.println(name);
        System.out.println(name2);
    }
    @Test
    public void getValueByName() {
        String value = EnumUtils.getValueByName(TestStrEnum.values(), "String类型测试1");
        Integer value2 = EnumUtils.getValueByName(TestIntEnum.values(), "Integer类型测试2");
        System.out.println(value);
        System.out.println(value2);
    }
    @Test
    public void getEnumByValue() {
        TestIntEnum enumByValue = EnumUtils.getEnumByValue(TestIntEnum.values(), 1);
        TestStrEnum test = EnumUtils.getEnumByValue(TestStrEnum.class, "02");
    }
}