【Java基础】EnumSet

当需要使用位运算时，可能你会如此定义

private final static int FIRST = 1;
private final static int SECOND = 1 << 1;
private final static int THIRD = 1 << 2;

使用时进行与或运算。但是定义多了之后，会很乱、臃肿，编写容易出错。EnumSet可以实现类似的功能，且使用起来很简洁。

示例

public enum EnumTest {
    FIRST,
    SECOND;

    public static void main(String[] args) {
        EnumSet<EnumTest> enumTests = EnumSet.allOf(EnumTest.class);
        //输出enumTests所有元素
        System.out.println(enumTests);//[FIRST, SECOND]

        //判断集中中是否存在
        System.out.println(enumTests.contains(EnumTest.SECOND));//true
    }
}

属性

final Class<E> elementType;

final Enum<?>[] universe;

elementType为EnumSet存储的元素类型，示例中为EnumTest。universe为存储的所有枚举实例数组。

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为EnumSet的两个实现类。当枚举中定义的实例数不大于64时，生成RegularEnumSet，否则生成JumboEnumSet。

allOf

public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType) {
        EnumSet<E> result = noneOf(elementType);
        result.addAll();
        return result;
    }

在allOf先调用noneOf获得EnumSet（RegularEnumSet或JumboEnumSet），allAll是个抽象方法，看下RegularEnumSet中是如何实现的

//RegularEnumSet.java

private long elements = 0L;

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

elements代表了EnumSet中存储的所有枚举实例所代表的bit数。示例中存储了FIRST和SECOND，分别代表了1和2，所以allAll之后，elements为3。

of

public static <E extends Enum<E>> EnumSet<E> of(E e) {
        EnumSet<E> result = noneOf(e.getDeclaringClass());
        result.add(e);
        return result;
    }

of方法有好几个，参数不同罢了。这里指只说单元素的情况。getDeclaringClass获取e的枚举类型。这里有个问题，为什么不用getClass。在示例中，这两种返回的都是EnumTest。再看另一种情况

public enum EnumTest {
    FIRST {
        @Override
        void doSometing() {

        }
    },
    SECOND {
        @Override
        void doSometing() {

        }
    };

    abstract void doSometing();

    public static void main(String[] args) {
        System.out.println(EnumTest.SECOND.getClass());//EnumTest$2
        System.out.println(EnumTest.SECOND.getDeclaringClass());//EnumTest
    }
}

当枚举有方法实现时，此时相当于内部类，getClass和getDeclaringClass返回的结果就不一样了。

public final Class<E> getDeclaringClass() {
        Class<?> clazz = getClass();//获取自己的Class
        Class<?> zuper = clazz.getSuperclass();//获取父类的Class
        return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;//两者不等时取父类
    }

说回来，获取类型之后，调用noneOf。调用add方法。

//RegularEnumSet.java
public boolean add(E e) {
        typeCheck(e);//校验e的类型是否和生成elementType一致

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

如果此时e为EnumTest.SECOND，ordinal为1，那么elements与运算后则为2。

contains

contains为AbstractCollection中的方法，EnumSet并没有覆写，而是交给两个子类去实现的。

//RegularEnumSet.java
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;
    }

contains最终算的就是枚举值对应的比特位是否被置位。

总结

枚举自带自增长的属性ordinal，可以和位运算完美的结合在一起。EnumSet的根本就是利用了这个特性，将ordinal和位运算封装起来，用户只需要像使用Set一样使用它。