Java1.8-RegularEnumSet和JumboEnumSet源码解析

RegularEnumSet概述

EnumSet毕竟只是个抽象类，我们在使用的时候都是使用它的两个实现类：RegularEnumSet，JumboEnumSet。其实在说EnumSet的noneof方法的时候已经说过，当EnumSet的容量大于64的时候，创建的是JumboEnumSet，否则创建的是RegularEnumSet。

因为具体的操作（比如add操作）毕竟是在实现类中的，所以我们现在先来分析一下RegularEnumSet这个类。

属性

/**
 * Private implementation class for EnumSet, for "regular sized" enum types
 * (i.e., those with 64 or fewer enum constants).
 */
class RegularEnumSet<E extends Enum<E>> extends EnumSet<E> {
    // 使用位向量保存
    private long elements = 0L;
    // 构造方法也是调用抽象类的构造方法来实现
    RegularEnumSet(Class<E>elementType, Enum<?>[] universe) {
        super(elementType, universe);
    }
}

从文档及结构上我们可以得出几点结论：

RegularEnumSet是枚举类型的私有实现类，我们无法直接调用，我们只能使用EnumSet，而EnumSet则会根据length相应的调用RegularEnumSet实现类；

RegularEnumSet保存数据和常规的Set不同，RegularEnumSet中只有一个long类型的elements变量，这是因为保存的时候保存的并不是实际的元素，而是保存的是bit，0和1；

方法

add方法

/**
 * 如果元素不存在，添加
 */
public boolean add(E e) {
    // 校验枚举类型
    typeCheck(e);

    long oldElements = elements;
    elements |= (1L << ((Enum<?>)e).ordinal());
    return elements != oldElements;
}

/**
 * 用于校验枚举类型，位于EnumSet中
 */
final void typeCheck(E e) {
    Class<?> eClass = e.getClass();
    if (eClass != elementType && eClass.getSuperclass() != elementType)
        throw new ClassCastException(eClass + " != " + elementType);
}

add方法中的位运算其实很有意思，首先，每一个枚举元素都有一个属性ordinal，用来表示该元素在枚举类型中的次序或者说下标。

add过程

add之后，elements二进制对应的ordinal位设置为了1。其实，add操作就是设置long类型的elements对应下标位置的值是0或者是1，也就是将每一个枚举元素在elements的二进制中占用一位。因为long是64位，所以RegularEnumSet的长度自然是不能大于64的。
还有一点，就是判断元素是否添加成功，直接通过判断添加前后elements的值有没有变化来判断。

其实，明白了这点之后，后面的许多操作都很简单了。

size方法

public int size() {
        return Long.bitCount(elements);
    }

其实size方法的实现是通过Long类型的bitCount来实现的，就是统计long类型二进制中1的个数。

addAll方法

void addAll() {
    if (universe.length != 0)
        elements = -1L >>> -universe.length;
}

addAll方法就是将elements上，从低位到枚举长度上的下标值置为1。比如某一个枚举类型共5个元素，而addAll就是将elements的二进制的低5位置为1。

addAll方法这里涉及到了无符号右移的操作，其实，这个操作也挺有意思，但具体的实现我把它放到另一篇专门介绍位运算符的文章里了。链接：Java位运算学习

addRange方法

void addRange(E from, E to) {
    elements = (-1L >>>  (from.ordinal() - to.ordinal() - 1)) << from.ordinal();
}

该方法是添加枚举中某一段范围内的元素。这个方法同样设计的也很精巧，先右无符号位移，将最低位置为0，然后左移对应的位置即可。

complement方法

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

这个方法其实和上面类似，只不过多了一步按位非的操作。
其他方法其实都是和上面这几个方法大差不差，只要明白了位运算，基本上这些方法都可以很快理解的。

最后，再说一个很有意思的方法：EnumSetIterator的next方法

private class EnumSetIterator<E extends Enum<E>> implements Iterator<E> {
    /**
     *  elements的值
     */
    long unseen;

    /**
     * elements二进制对应的1的位置
     */
    long lastReturned = 0;

    EnumSetIterator() {
        unseen = elements;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        if (unseen == 0)
            throw new NoSuchElementException();
        lastReturned = unseen & -unseen;
        unseen -= lastReturned;
        return (E) universe[Long.numberOfTrailingZeros(lastReturned)];
    }
}

首先，lastReturned = unseen & -unseen; 计算的是unseen的二进制最低位第一个非0位代表的十进制数。如果unseen是0111，那返回的就是0001，十进制是1，如果unseen是0100，那返回的就是0100，十进制是4。
而 Long.numberOfTrailingZeros(lastReturned) 计算的是lastReturned从最低位开始，第一位为1的下标值（或者换一种说法，就是从最低位开始，到第一位为1这中间0的个数）。比如lastReturned是4，二进制是0100，那这里返回的就是2；如果lastReturned是0101，那这里返回的就是0。
依稀记得leetcode中有一个算法就是计算尾部的零的个数（Trailing Zeros）。

这里，其实只要过一遍流程基本就清楚了。

总结

其实RegularEnumSet中进行的操作就是围绕长整型elements的二进制位上的1和0进行的。添加元素，设置为1，删除元素，设置为0，清空，直接将该长整型置为0。

JumboEnumSet概述

当枚举元素的个数超过了64之后，就将使用JumboEnumSet来进行操作。其实JumboEnumSet中大部分操作和RegularEnumSet都差不多，有一点不太一样的就是JumboEnumSet里的elements是个long类型的数组。

private long elements[];

所以，JumboEnumSet中有一步操作就是定位到数组中对应的long元素上。

构造方法

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

这里 new long[(universe.length + 63) >>> 6];，无符号右移可以大致认为除以64，计算的就是数组的容量。

我们再随便拿一个方法说一下：

addAll方法

void addAll() {
    for (int i = 0; i < elements.length; i++)
        elements[i] = -1;
    elements[elements.length - 1] >>>= -universe.length;
    size = universe.length;
}

这里处理的很巧妙。首先，循环设置数组里的long是-1，-1的二进制是1111....1111，所以 elements[elements.length - 1] >>>= -universe.length; 这一步，就是计算long数组中最后一个long元素二进制位上的1和0；

比如说，枚举元素是68个，那么elements数组的第一个long元素已经在循环的时候设置为了-1，也就是1111....1111，进行这一步进行的就是将第二个long元素进行位移运算，结果为0000....0000 1111。

其他的就没什么说的了，总之，只要明白了位运算，这些方法还是挺简单的。

本文参考自：
JDK源码解读之RegularEnumSet