【Java5 特性】3.Java枚举

最新推荐文章于 2022-09-13 16:29:58 发布

谁是谁的小确幸

最新推荐文章于 2022-09-13 16:29:58 发布

阅读量268

点赞数 2

分类专栏： Java 文章标签： Java枚举接口与枚举单例模式 EnumMap EnumSet

本文链接：https://blog.csdn.net/qq_29119581/article/details/112093160

版权

Java 专栏收录该内容

40 篇文章 0 订阅

订阅专栏

四、EnumMap容器与EnumSet容器

1、EnumMap映射

2、EnumSet集合

小结

一、枚举概念

枚举（Enum）是Java5时引入的特性，本质上也是一个class类型，属于引用数据类型，定义时用enum关键字标识。简单的定义一个枚举类：（注意：命名规范强制要求使用Enum结尾，这样可以清晰表明它的类型！）

public enum CarEnum {
    AUDI, BMW, GEELY, KIA, CHANGAN
}

与普通类相比，枚举类有哪些不同呢？

枚举类用enum关键字标识，而普通类用class关键字标识；
所有自定义的枚举类均默认继承自java.lang.Enum，且自定义的枚举类无法extends其他枚举类，也不能被继承；
枚举的实例是直接定义的，比如AUDI, BMW, GEELY等，而普通类一般是new的方式构造的；
使用也很简单，通过 CarEnum.AUDI 方式使用枚举常量，而枚举常量在JVM中的实例是唯一的，因此可直接使用==进行枚举常量的比较；
switch多重选择语句支持枚举类型，不支持普通类；

正是因为枚举这些独特的特征，使得枚举具有简便性和安全性，Enum类及常用的API需要了解一下，找到java.lang包下Enum类的源码，简单分析一下：

/**
 * Enum 是一个抽象泛型类，实现了Comparable接口和Serializable接口，说明Enum可排序，可序列化！
 **/
public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {
    /** 常量名称属性 */
    private final String name;
    /** 常量在Enum 中的位置索引属性 */
    private final int ordinal;
    /** 构造方法 */
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }
    /** 获取字符串常量名 */
    public final String name() {return name;}
    /** 获取常量在Enum 中的位置 */
    public final String ordinal() {return ordinal;}
    /** 同 name() */
    public String toString() {return name;}
    /** toString()的逆方法：将字符串常量名设置为枚举常量 */
    public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }
    
    public final boolean equals(Object other) {return this==other;}
    public final int hashCode() {return super.hashCode();}
    public final int compareTo(E o) {...}
}

需要注意一下name()方法和toString()方法，它们都是获取枚举类的常量字符串名称，并且修饰符不同，因此自定义枚举类时可以重写toString()方法，但不能重写final的name()方法，建议使用name()方法获取字符串名称。另外，静态的valueOf()方法是与toString()方法相反的一种方法，即可以往指定枚举类添加枚举常量。自定义枚举类中有一个静态的values()方法值得关注，它返回的是一个包含全部枚举值的数组，比如：CarEnum[] carValues = CarEnum.values(); 。

二、枚举的应用

1、switch语句支持枚举类型

Java5除了新增枚举特性之外，还在switch语句内提供了对枚举类型的支持，举个例子说明：

public class Test {
    public static void main(String[] args) {
        // 当前版本Java8，switch支持类型有：枚举，字符串，char/byte/short/int及对应的包装类
        CarEnum car = CarEnum.GEELY;
        switch (car) {
            case AUDI:
                System.out.println("我是奥迪汽车！");
                break;
            case BMW:
                System.out.println("我是宝马汽车！");
                break;
            case GEELY:
                System.out.println("我是吉利汽车！");
                break;
            case CHANGAN:
                System.out.println("我是长安汽车！");
                break;
            default:
                System.out.println("我是东风起亚汽车！");
        }
    }
}

2、常量接口与枚举类的对比

常量是一种定义后值不能再被改变的变量，实际开发中都会去统一管理我们用到的常量，比如会使用一个类或一个接口去维护，以常量接口Road为例：

public interface Road {
    /**
     * 道路平坦度
     */
    char ROAD_WORD_1 = '1';
    char ROAD_WORD_2 = '2';
    /**
     * 道路等级
     */
    int ROAD_LEVEL_1 = 1;
    int ROAD_LEVEL_2 = 2;
    /**
     * 道路类型名称
     */
    String HIGH_ROAD = "高速公路";
    String FAST_ROAD = "城市快速路";
    String MIDDLE_ROAD = "一般公路";
}

public class Test {
    public static void main(String[] args) {
        int level = 1;
        System.out.println("每日一问，你走的是什么路：" + Road.HIGH_ROAD);
        if (level == Road.ROAD_WORD_1)
            System.out.println("不同基本类型的常量能进行比较？？？？");
        if (level == Road.ROAD_LEVEL_1)
            System.out.println("目前道路等级达标！");
    }
}

Road常量接口中可以定义任意Java类型的常量，常量均省略了默认的修饰符public static final，常量名称均大写且多个单词要使用下划线隔开，直接通过 接口名.常量名 调用，在不同类型的常量进行比较时，编译器只是提示了建议移除if表达式，没有报错。

如果使用枚举类型存储这些常量的话，如何改造上面的常量接口Road呢？定义一个枚举类RoadEnum：

public enum RoadEnum {
    /** 枚举常量只指定了默认名称，而索引顺序省略的话，则默认按照当前的位置顺序 */
    ROAD_WORD_1('1'), ROAD_WORD_2('2'),
    ROAD_LEVEL_1(1), ROAD_LEVEL_2(2),
    HIGH_ROAD("高速公路"), FAST_ROAD("城市快速路"), MIDDLE_ROAD("一般公路");

    /** 常量名称 */
    public char charName;
    public int intName;
    public String strName;

    /** 通过构造器初始化常量名称 */
    RoadEnum(char charName) {
        this.charName = charName;
    }

    RoadEnum(int intName) {
        this.intName = intName;
    }

    RoadEnum(String strName) {
        this.strName = strName;
    }

    /** 便于打印和追踪枚举信息，强制要求重写toString() */
    @Override
    public String toString() {
        return "RoadEnum{" +
                "charName=" + charName +
                ", intName=" + intName +
                ", strName='" + strName + '\'' +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
//        System.out.println("每日一问，你走的是什么路：" + RoadEnum.HIGH_ROAD); // RoadEnum{charName= , intName=0, strName='高速公路'}
        System.out.println("每日一问，你走的是什么路：" + RoadEnum.HIGH_ROAD.ordinal()); // 4
//        System.out.println("每日一问，你走的是什么路：" + RoadEnum.HIGH_ROAD.name()); // HIGH_ROAD
//        System.out.println("每日一问，你走的是什么路：" + RoadEnum.HIGH_ROAD.toString()); // RoadEnum{charName= , intName=0, strName='高速公路'}
        System.out.println("每日一问，你走的是什么路：" + RoadEnum.HIGH_ROAD.strName); // 高速公路

        /** 比较测试 */
        int level = 1;
        if (level == RoadEnum.ROAD_WORD_1.charName)
            System.out.println("不同基本类型的常量能进行比较？？？？");
        if (level == RoadEnum.ROAD_LEVEL_1.intName)
            System.out.println("目前道路等级达标！");
        if (RoadEnum.ROAD_WORD_1 == RoadEnum.ROAD_LEVEL_1)
            System.out.println("枚举常量实例之间的比较");

        /** 遍历枚举 */
        RoadEnum[] roadEnums = RoadEnum.values();
        System.out.print("枚举集合内的元素有:");
        for (int i = 0; i < roadEnums.length; i++) {
//            System.out.print(roadEnums[i].charName + " "); // 12
//            System.out.print(roadEnums[i].intName + " "); // 0 0 1 2 0 0 0
            System.out.print(roadEnums[i].strName + " "); // null null null null 高速公路 城市快速路 一般公路 
        }
    }
}

从改造的结果来看，我们可以总结出：

枚举常量的实例可以省略常量名称（即name属性）和常量索引（即ordinal属性），也可以指定默认的常量名称，此时不指定常量索引的话，会将当前所在枚举的位置当做默认索引；
通过name()方法只是获取了枚举常量的实例，而要获取枚举常量实例的字符串名称，则需要调用构造器内维护的那个成员变量才行；
枚举类重写了toString()方法，在执行RoadEnum.HIGH_ROAD 或 RoadEnum.HIGH_ROAD.toString()时就可以很清晰的打印枚举中信息；
基本类型可以用 == 比较，枚举常量的实例之间也可以用 == 比较，枚举常量的实例是唯一的，没必要使用equals()比较；
枚举作为一种有限的集合容器，可以通过静态方法values()获取枚举数组，而遍历获取某一类型的枚举常量时，其他的枚举常量则全部设为默认值（比如：int默认0，String默认null）。

3、枚举实现单例模式

使用枚举，是实现单例模式的最简单方式，而且不会存在如 —— 反序列化时重新生成新对象破坏单例模式、反射时会强行调用构造器实例化单例类等问题，推荐使用。代码实现如下：

public enum SingleInstanceEnum {
    INSTANCE; 
}

@Test
void testEnum(){
    SingleInstanceEnum instance = SingleInstanceEnum.INSTANCE;
}

哈哈哈，这里突然强迫症有些犯了，为什么枚举能避免上述提及的那两个问题呢，这篇作为专门整理枚举基础知识的文章，有必要去深究一下这些问题其中的原因。

枚举与反序列化

从上面Enum枚举的源码中可以看到：Enum类实现了Serializable接口，说明枚举实例是可序列化的，序列化输出的内容是枚举实例的name属性。而反序列化时是否也会像普通的类那样会生成新的对象呢？答案是不会。那么枚举实例在序列化过程中是一种什么状态呢，先看一下Enum类中的静态方法valueOf()，其源码的核心代码为：T result = enumType.enumConstantDirectory().get(name); ，意思是它会根据传入的枚举实例的引用（enumType）和枚举常量的字符串名称（name）返回一个枚举实例（T），其中，enumType调用enumConstantDirectory()方法返回一个Map集合，该Map集合存储了以name属性为key，以枚举实例为value的数据。

再看一下enumConstantDirectory()方法的源码，将获取的枚举实例存在了一个Map结构中，然后赋值给了另一个用transient标识的不参与序列化的Map，这里就真相大白了。由此可以得知：枚举实例本质上存放在了不参与序列化过程的Map结构中，反序列化后仍然是这些枚举实例，且枚举实例是唯一的。因此，使用枚举实现单例模式是高效的，安全的。

Map<String, T> enumConstantDirectory() {
    if (enumConstantDirectory == null) {
        // 获取枚举实例，并检查合法性
        T[] universe = getEnumConstantsShared();
        if (universe == null)
            throw new IllegalArgumentException(
                getName() + " is not an enum type");
        // 通过Map存储枚举实例：以name为key，以枚举常量为value
        Map<String, T> m = new HashMap<>(2 * universe.length);
        for (T constant : universe)
            m.put(((Enum<?>)constant).name(), constant);
        // 将该Map设置为不参与序列化的Map
        enumConstantDirectory = m;
    }
    return enumConstantDirectory;
}
/** transient标识该Map不会参与序列化 */ 
private volatile transient Map<String, T> enumConstantDirectory = null;

枚举与反射

定义一个普通的VO类和一个枚举类，通过.class属性的方式获取反射对象，测试如下：

public class Test {
    public static void main(String[] args) 
            throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        OrderVO order = OrderVO.class.newInstance();
        System.out.println(order.toString()); // Order@b1a58a3

        CarEnum car = CarEnum.class.newInstance();
        System.out.println(car.toString()); // java.lang.InstantiationException

        CarEnum car1 = CarEnum.class.getConstructor().newInstance();
        System.out.println(car1.toString()); // java.lang.NoSuchMethodException
    }
}

普通的VO类获取反射结构是正常的，而枚举类CarEnum分别通过Class类的newInstance()、构造器类的newInstance()方式均不能获取反射对象，从debug调试源码可知，Class类的newInstance()本质上运行的是构造器类的newInstance()，当断点最后运行到Class类的newInstance()方法中的 final Constructor c = getConstructor0(empty, Member.DECLARED); c.setAccessible(true); 等处时抛出了NoSuchMethodException异常，具体异常信息为：com.it.entity.CarEnum.<init>()，注意<init>()是个啥？它看起来像泛型方法（我猜可能是一种泛型构造器？？），接着联想起了运行期间泛型类型会被擦除，JVM只会处理原始类型的类或方法，然而通过反射出现了<init>()， JVM应该是没办法处理了，所以直接抛了异常。这说明枚举不能通过反射的方式获取构造器并进行初始化成员，因此枚举实现单例模式是可靠的。

4、使用接口组织枚举

上面为了改造常量接口Road，定义了一个枚举类RoadEnum，该枚举类中大致定义了三种类型的常量，直观上给人感觉耦合度较高，且不优雅。这里利用接口组织枚举的方式，更优雅的使用枚举，改造如下：

public interface RoadE2I {
    /** 道路平坦度枚举 */
    enum WordEnum {
        ROAD_WORD_1('1'), ROAD_WORD_2('2');
        public char charName;

        WordEnum(char charName) {
            this.charName = charName;
        }
    }

    /** 道路等级枚举 */
    enum LevelEnum {
        ROAD_LEVEL_1(1), ROAD_LEVEL_2(2);
        public int intName;

        LevelEnum(int intName) {
            this.intName = intName;
        }
    }
    /** 道路类型枚举 */
    enum SpeedEnum {
        HIGH_ROAD("高速公路"), FAST_ROAD("城市快速路"), MIDDLE_ROAD("一般公路");
        public String strName;

        SpeedEnum(String strName) {
            this.strName = strName;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("--------->" + RoadE2I.WordEnum.ROAD_WORD_1.charName); // 1
        System.out.println("--------->" + RoadE2I.LevelEnum.ROAD_LEVEL_2.intName); // 2
        System.out.println("--------->" + RoadE2I.SpeedEnum.HIGH_ROAD.strName); // 高速公路
    }
}

四、EnumMap容器与EnumSet容器

1、EnumMap映射

EnumMap顾名思义是专门为枚举设计的一种Map结构，想要了解和使用它，还得看一下源码，分析见源码注释：

/**
 * EnumMap：key做了泛型上界限定，必须是枚举类型或枚举类型的子类型，
 *    继承自AbstractMap，具有Map通用的特点，又实现了Serializable、Cloneable等接口。
 *    这里只重点分析构造方法/get()/put()/remove()等方法
 **/
public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>
    implements java.io.Serializable, Cloneable
{
    /** 枚举类型 */
    private final Class<K> keyType;
    /** 枚举常量实例 ，做为EnumMap的key*/
    private transient K[] keyUniverse;
    /** 枚举实例的name属性 ，做为EnumMap的value*/
    private transient Object[] vals;
    /** EnumMap大小 */
    private transient int size = 0;

    /** EnumMap构造器入参有三种方式：Class<K>、 EnumMap、普通的Map，以Class<K>为例*/
    public EnumMap(Class<K> keyType) {
        this.keyType = keyType;
        keyUniverse = getKeyUniverse(keyType);
        vals = new Object[keyUniverse.length];
    }

    /** 添加k-v */
    public V put(K key, V value) {
        typeCheck(key);

        int index = key.ordinal();
        Object oldValue = vals[index];
        vals[index] = maskNull(value);
        if (oldValue == null)
            size++;
        return unmaskNull(oldValue);
    }

    /** 根据key获取value */
    public V get(Object key) {
        return (isValidKey(key) ?
                unmaskNull(vals[((Enum<?>)key).ordinal()]) : null);
    }

    /** 根据key删除value */
    public V remove(Object key) {
        if (!isValidKey(key))
            return null;
        int index = ((Enum<?>)key).ordinal();
        Object oldValue = vals[index];
        vals[index] = null;
        if (oldValue != null)
            size--;
        return unmaskNull(oldValue);
    }

    /** 判断是否存在指定key */
    public boolean containsKey(Object key) {...}
    /** 判断是否存在指定value */
    public boolean containsValue(Object value) {...}

    /** 验证key的合法性 */
    private boolean isValidKey(Object key) {...}
    /** key的类型检查 */
    private void typeCheck(K key) {...}
    /** 将value中的null标记为NULL */
    private Object maskNull(Object value) {return (value == null ? NULL : value);}
    /** 取消value中标记的NULL */
    private V unmaskNull(Object value) {return (V)(value == NULL ? null : value);}

    /** 返回所有的value */
    public Collection<V> values() {...}
    /** 返回带Map的Set集合 */
    public Set<Map.Entry<K,V>> entrySet() {...}
    /** 返回Set集合 */
    public Set<K> keySet() {...}
}

EnumMap中通过put()方法存放键值对k-v，get()方法获取键的值，remove()删除键值对，containsKey()/containsValue()判断key/value是否存在，及遍历等操作，当然也可以使用其他的Map如HashMap操作，EnumMap具有Map的通用特性，只不过EnumMap是面向Enum对象操作的，demo演示：

public class Test {
    public static void main(String[] args) {
        EnumMap<CarEnum, Long> map = new EnumMap<>(CarEnum.class);
        // 添加
        map.put(CarEnum.AUDI, 250000L);
        map.put(CarEnum.BMW, 650000L);
        map.put(CarEnum.GEELY, 147000L);
        // 获取
        System.out.println(map.get(CarEnum.GEELY)); // 147000L
        System.out.println(map.get(CarEnum.CHANGAN)); // null
        // 计算花费总和
        Long sum = map.get(CarEnum.AUDI) + map.get(CarEnum.BMW) + map.get(CarEnum.GEELY);
        System.out.println(sum); // 1047000
        // 判断和删除
        if (map.containsKey(CarEnum.KIA))
            map.remove(CarEnum.KIA);
        // 遍历值 
        map.values().forEach(r -> System.out.print(r + " ")); // 250000 650000 147000
        // 遍历枚举实例
        map.keySet().forEach(s -> System.out.print(s + " ")); // AUDI BMW GEELY
        // 遍历EnumMap
        for (Map.Entry<CarEnum, Long> ce : map.entrySet()) {
            System.out.println(ce.getKey().name() + ":" + ce.getValue()); // AUDI:250000 BMW:650000 BMW:650000
        }
    }

EnumMap的键Key维护的是一个泛型数组K[]，准确的说是枚举类型的数组，用于存放枚举常量实例，而值Value维护的是一个对象数组，用于存放枚举常量实例的名称（即name属性）。数组的优势在于访问速度快，在EnumMap中的put()、remove()、get()巧妙地将枚举实例，在枚举类中的索引位置（即ordinal属性），与在数组上的位置（即index属性）一一对应了起来，不需要进行像HashMap那样的hash计算了（或者说EnumMap不存在哈希冲突问题）。增删改查等操作时，通过该索引可以快速定位数组元素，因此，EnumMap的效率高且没有额外的内存空间开销。

2、EnumSet集合

EnumSet是为枚举专门设计的一种Set集合，同样地，通过源码去了解和使用EnumSet：

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
    implements Cloneable, java.io.Serializable
{
    /** EnumSet存储的元素类型 */
    final Class<E> elementType;
    /** 枚举类型 */
    final Enum<?>[] universe;
    /** EnumSet 构造器 */
    EnumSet(Class<E>elementType, Enum<?>[] universe) {
        this.elementType = elementType;
        this.universe    = universe;
    }
    
    /** 通过noneOf()方式创建一个空的EnumSet */
    public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {
        Enum<?>[] universe = getUniverse(elementType);
        if (universe == null)
            throw new ClassCastException(elementType + " not an enum");
        // 这里是选择操作的实现类Set集合
        if (universe.length <= 64)
            return new RegularEnumSet<>(elementType, universe);
        else
            return new JumboEnumSet<>(elementType, universe);
    }

    /** 通过allOf()方式创建一个包含所有枚举值的EnumSet */
    public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType) {...}
    /** 通过copyOf()方式复制一个 EnumSet 或  Collection*/
    public static <E extends Enum<E>> EnumSet<E> copyOf(EnumSet<E> s) {...}
    public static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c) {...}
    /** 通过complementOf()方式创建一个 与传入EnumSet不包含的枚举值 的新EnumSet*/
    public static <E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> s) {...}
    /** 通过range()方式创建一个 具有指定区间的枚举值 的EnumSet*/
    public static <E extends Enum<E>> EnumSet<E> range(E from, E to) {...}
    /** 通过of()方式创建一个 包含一个或多个枚举值 的EnumSet*/
    public static <E extends Enum<E>> EnumSet<E> of(E e) {...}
    public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2) {...}
    public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3) {...}
    ...
    @SafeVarargs
    public static <E extends Enum<E>> EnumSet<E> of(E first, E... rest) {...}
}

这里EnumSet只是一个抽象类，继承了AbstractSet类，说明EnumSet的实现类具有Set集合通用的特性。EnumSet类中提供了许多创建EnumSet集合的静态方法，具体用法已注释。有两个实现类RegularEnumSet和JumboEnumSet，在实现类中提供了remove()、add()、size()、contains()、iterator()及交并差操作等方法，使用时与其他的Set集合并没有多大差别，只不过EnumSet是面向枚举的。