Java枚举之EnumSet详解

目录

• EnumSet
• 示例
• 属性 
• noneOf
• allOf
• of
• contains
• 总结

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)
            th编程客栈row 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 elemandroidents = 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 ejavascriptlements != 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最终算的就是枚举值对应的比特位是http://www.devze.com否被置位。

总结

枚举自带自增长的属性ordinal，可以和位运算完美的结合在一起。

EnumSet的根本就是利用了这个特性，将ordinal和位运算封装起来，用户只需要像使用Set一样使用它。

到此这篇关于Java枚举之EnumSet详解的文章就介绍到这了,更多相关Java枚举EnumSet内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！