深入学习EnumSet

Set接口的实现类HashSet/TreeSet，它们内部都是用对应的HashMap/TreeMap实现的，
但EnumSet的实现与EnumMap没有任何关系，而是用极为精简和高效的位向量实现的，

除了实现机制，EnumSet的用法也有一些不同。与TreeSet/HashSet不同，
EnumSet是一个抽象类，不能直接通过new新建，EnumSet提供了若干静态工厂方法创建EnumSet类型的对象，比如：
public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType)
noneOf方法会创建一个指定枚举类型的EnumSet，不含任何元素。
创建的EnumSet对象的实际类型是EnumSet的子类

enum Color{
 
    RED,BLUE,YELLOW
}

Set<Color> colorSet = EnumSet.noneOf(Color.class);

colorSet.add(Color.RED);

colorSet.add(Color.BLUE);

System.out.println(colorSet);

输出结果为
[RED, BLUE]

EnumSet还有很多其他静态工厂方法，如下所示(省略了修饰public static)：

// 初始集合包括枚举值中指定范围的元素
<E extends Enum<E>> EnumSet<E> range(E from, E to)
// 初始集合包括指定集合的补集
<E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> s)

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


EnumSet的应用：
下面，我们通过一个场景来看EnumSet的应用。
想象一个场景，在一些工作中，比如医生、客服，不是每个工作人员每天都在的，每个人可工作的时间是不一样的，比如张三可能是周一和周三，李四可能是周四和周六，给定每个人可工作的时间，我们可能有一些问题需要回答，比如：
有没有哪天一个人都不会来？
有哪些天至少会有一个人来？
有哪些天至少会有两个人来？
有哪些天所有人都会来，以便开会？
哪些人周一和周二都会来？ 
使用EnumSet，可以方便高效地回答这些问题，怎么做呢？我们先来定义一个表示工作人员的类Worker，如下所示：

enum Day {
    MONDAY, TUESDAY, WEDNESDAY,
    THURSDAY, FRIDAY, SATURDAY, SUNDAY
}


class Worker {
    String name;
    Set<Day> availableDays;
    
    public Worker(String name, Set<Day> availableDays) {
        this.name = name;
        this.availableDays = availableDays;
    }
    
    public String getName() {
        return name;
    }
    
    public Set<Day> getAvailableDays() {
        return availableDays;
    }
}

每个工作人员的可工作时间用一个EnumSet表示。有了这个信息，我们就可以回答以上的问题了。
哪些天一个人都不会来？代码可以为：

Set<Day> days = EnumSet.allOf(Day.class);

for(Worker w : workers){
 
    days.removeAll(w.getAvailableDays());
}
}

System.out.println(days);

days初始化为所有值，然后遍历workers，从days中删除可工作的所有时间，最终剩下的就是一个人都不会来的时间，这实际是在求worker时间并集的补集，输出为：
[SUNDAY]

Set<Day> days = EnumSet.noneOf(Day.class);

for(Worker w : workers){
 
    days.addAll(w.getAvailableDays());
}
}
S
System.out.println(days);
输出为：
[MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY

有哪些天所有人都会来？就是求worker时间的交集，代码可以为：

Set<Day> days = EnumSet.allOf(Day.class);

for(Worker w : workers){
 
    days.retainAll(w.getAvailableDays());
}
}
S
System.out.println(days);
输出为：

[TUESDAY]

.....

实现原理
位向量
EnumSet是使用位向量实现的，什么是位向量呢？就是用一个位表示一个元素的状态，用一组位表示一个集合的状态，每个位对应一个元素，而状态只可能有两种。
对于之前的枚举类Day，它有7个枚举值，一个Day的集合就可以用一个字节byte表示，最高位不用，设为0，最右边的位对应顺序最小的枚举值，从右到左，每位对应一个枚举值，1表示包含该元素，0表示不含该元素。
比如，表示包含Day.MONDAY，Day.TUESDAY，Day.WEDNESDAY，Day.FRIDAY的集合，位向量图示结构如下

0         0           0          1             0           1            1         1
        周日     周六     周五    周四     周三     周二   周一

对应的整数是23。
位向量能表示的元素个数与向量长度有关，一个byte类型能表示8个元素，一个long类型能表示64个元素，那EnumSet用的长度是多少呢？
EnumSet是一个抽象类，它没有定义使用的向量长度，它有两个子类，RegularEnumSet和JumboEnumSet。RegularEnumSet使用一个long类型的变量作为位向量，long类型的位长度是64，而JumboEnumSet使用一个long类型的数组。如果枚举值个数小于等于64，则静态工厂方法中创建的就是RegularEnumSet，大于64的话就是JumboEnumSet。



我们来看EnumSet的实现，它有表示类型信息和所有枚举值的实例变量，如下所示：

final Class<E> elementType;

final Enum[] universe;

elementType表示类型信息，universe表示枚举类的所有枚举值。
EnumSet自身没有记录元素个数的变量，也没有位向量，它们是子类维护的。
对于RegularEnumSet，它用一个long类型表示位向量，代码为：

private long elements = 0L;

它没有定义表示元素个数的变量，是实时计算出来的，计算的代码是：
public int size() {
 
    return Long.bitCount(elements);
}
}

对于JumboEnumSet，它用一个long数组表示，有单独的size变量，代码为：
private long elements[];

private int size = 0;

静态工厂方法
我们来看EnumSet的静态工厂方法noneOf，代码为：

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);
}

RegularEnumSet和JumboEnumSet的构造方法为：

RegularEnumSet(Class<E>elementType, Enum[] universe) {
    super(elementType, universe);
}
JumboEnumSet(Class<E>elementType, Enum[] universe) {
    super(elementType, universe);
    elements = new long[(universe.length + 63) >>> 6];
}

它们都调用了父类EnumSet的构造方法，其代码为：

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

添加元素：
RegularEnumSet的add方法的代码为：

public boolean add(E e) {
    typeCheck(e);
    long oldElements = elements;
    elements |= (1L << ((Enum)e).ordinal());
    return elements != oldElements;
}

1L << ((Enum)e).ordinal())将元素e对应的位设为1，与现有的位向量elements相或，就表示添加e了。从集合论的观点来看，这就是求集合的并集。
JumboEnumSet的add方法的代码为：

public boolean add(E e) {
    typeCheck(e);

    int eOrdinal = e.ordinal();
    int eWordNum = eOrdinal >>> 6;

    long oldElements = elements[eWordNum];
    elements[eWordNum] |= (1L << eOrdinal);
    boolean result = (elements[eWordNum] != oldElements);
    if (result)
        size++;
    return result;
}

与RegularEnumSet的add方法的区别是，它先找对应的数组位置，eOrdinal >>> 6就是eOrdinal除以64，eWordNum就表示数组索引，有了索引之后，其他操作与RegularEnumSet就类似了。
对于其他操作，JumboEnumSet的思路是类似的，主要算法与RegularEnumSet一样，主要是增加了寻找对应long位向量的操作，或者有一些循环处理，逻辑也都比较简单，后文就只介绍RegularEnumSet的实现了。
RegularEnumSet的addAll方法的代码为：

public boolean addAll(Collection<? extends E> c) {
    if (!(c instanceof RegularEnumSet))
        return super.addAll(c);

    RegularEnumSet es = (RegularEnumSet)c;
    if (es.elementType != elementType) {
        if (es.isEmpty())
            return false;
        else
            throw new ClassCastException(
                es.elementType + " != " + elementType);
    }

    long oldElements = elements;
    elements |= es.elements;
    return elements != oldElements;
}

删除元素
remove方法的代码为：

public boolean remove(Object e) {
    if (e == null)
        return false;
    Class eClass = e.getClass();
    if (eClass != elementType && eClass.getSuperclass() != elementType)
        return false;

    long oldElements = elements;
    elements &= ~(1L << ((Enum)e).ordinal());
    return elements != oldElements;
}

~是取反，该代码将元素e对应的位设为了0，这样就完成了删除。
从集合论的观点来看，remove就是求集合的差，A-B等价于A∩B'，B'表示B的补集。代码中，elements相当于A，(1L << ((Enum)e).ordinal())相当于B，~(1L << ((Enum)e).ordinal())相当于B'，elements &= ~(1L << ((Enum)e).ordinal())就相当于A∩B'，即A-B。



查看是否包含某元素：

public boolean contains(Object e) {
    if (e == null)
        return false;
    Class eClass = e.getClass();
    if (eClass != elementType && eClass.getSuperclass() != elementType)
        return false;

    return (elements & (1L << ((Enum)e).ordinal())) != 0; //这里判断交集是否为0 即可。
}

查看是否包含集合中的所有元素
containsAll方法的代码为：

public boolean containsAll(Collection<?> c) {
    if (!(c instanceof RegularEnumSet))
        return super.containsAll(c);

    RegularEnumSet es = (RegularEnumSet)c;
    if (es.elementType != elementType)
        return es.isEmpty();

    return (es.elements & ~elements) == 0; /
}

containsAll就是在检查参数c表示的集合是不是当前集合的子集。一般而言，集合B是集合A的子集，即B⊆A，等价于A'∩B是空集∅，A'表示A的补集



retainAll方法的代码为：

public boolean retainAll(Collection<?> c) {
    if (!(c instanceof RegularEnumSet))
        return super.retainAll(c);

    RegularEnumSet<?> es = (RegularEnumSet<?>)c;
    if (es.elementType != elementType) {
        boolean changed = (elements != 0);
        elements = 0;
        return changed;
    }

    long oldElements = elements;
    elements &= es.elements;
    return elements != oldElements;
}

求补集
EnumSet的静态工厂方法complementOf是求补集，它调用的代码是：

void complement() {
    if (universe.length != 0) {
        elements = ~elements;
        elements &= -1L >>> -universe.length;  // Mask unused bits
    }
}

-1L是64位全1的二进制（补码表示）
上面代码相当于：

elements &= -1L >>> (64-universe.length);
如果universe.length为7，则-1L>>>(64-7)就是二进制的1111111，与elements相与，就会将超出universe.length部分的右边的57位都变为0。
实现原理小结
以上就是EnumSet的基本实现原理，内部使用位向量，表示很简洁，节省空间，大部分操作都是按位运算，效率极高。