数据结构 - EnumSet 类

简介

同一个枚举类的对象如果用HashSet来放就太浪费空间了，因为HashSet内部还是使用HashMap散列方式，对于一个枚举类来说运行前都已经确定了顺序，并且枚举又不会特别多，继续使用HashSet就得不偿失了，JDK中提供EnumSet是专门用于服务枚举类型的，EnumSet和其他Set不太一样的地方，是它是有序的并且不允许插入null

EnumSet 类

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
        implements Cloneable, java.io.Serializable

EnumSet的值必须是枚举值，并且EnumSet是抽象类，EnumMap是实现类

EnumSet 属性

// 保存的数据类型
final Class<E> elementType;
// 保存数据的数组
final Enum<?>[] universe;
// 空枚举
private static Enum<?>[] ZERO_LENGTH_ENUM_ARRAY = new Enum<?>[0];

EnumSet 构造函数

EnumSet(Class<E>elementType, Enum<?>[] universe) {
    this.elementType = elementType;
    this.universe    = universe;
}

构造函数不是public的，只供子类继承时使用

EnumSet 基础方法

// 生成一个空的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");
    // 
    if (universe.length <= 64)
        return new RegularEnumSet<>(elementType, universe);
    else
        return new JumboEnumSet<>(elementType, universe);
}

EnumSet有两个子类：RegularEnumSet，JumboEnumSet，如果枚举元素的数量大于64，那么实际创建的是JumboEnumSet实现类，否则是RegularEnumSet实现类

// 枚举类转EnumSet
public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType) {
    EnumSet<E> result = noneOf(elementType);
    result.addAll();
    return result;
}
// 初始集合包括枚举值中指定范围的元素
public static <E extends Enum<E>> EnumSet<E> range(E from, E to) {
    if (from.compareTo(to) > 0)
        throw new IllegalArgumentException(from + " > " + to);
    EnumSet<E> result = noneOf(from.getDeclaringClass());
    result.addRange(from, to);
    return result;
}

EnumSet of方法

public static <E extends Enum<E>> EnumSet<E> of(E e) {
    EnumSet<E> result = noneOf(e.getDeclaringClass());
    result.add(e);
    return result;
}
public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2) {
    EnumSet<E> result = noneOf(e1.getDeclaringClass());
    result.add(e1);
    result.add(e2);
    return result;
}
public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3) {
    EnumSet<E> result = noneOf(e1.getDeclaringClass());
    result.add(e1);
    result.add(e2);
    result.add(e3);
    return result;
}
public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4) {
    EnumSet<E> result = noneOf(e1.getDeclaringClass());
    result.add(e1);
    result.add(e2);
    result.add(e3);
    result.add(e4);
    return result;
}
public static <E extends Enum<E>> EnumSet<E> of(E e1, E e2, E e3, E e4,
                                                E e5)
{
    EnumSet<E> result = noneOf(e1.getDeclaringClass());
    result.add(e1);
    result.add(e2);
    result.add(e3);
    result.add(e4);
    result.add(e5);
    return result;
}
public static <E extends Enum<E>> EnumSet<E> of(E first, E... rest) {
    EnumSet<E> result = noneOf(first.getDeclaringClass());
    result.add(first);
    for (E e : rest)
        result.add(e);
    return result;
}

EnumSet有很多重载形式的of方法，最后一个接受的的是可变参数，其他重载方法看上去是多余的，之所以有其他重载方法是因为可变参数的运行效率低一些。