Java枚舉之EnumSet詳解

更新時間：2023年12月20日 10:07:05 作者：Brain_L

這篇文章主要介紹了Java枚舉之EnumSet詳解,使用時進行與或運算,但是定義多了之后,會很亂、臃腫,編寫容易出錯,EnumSet可以實現(xiàn)類似的功能,且使用起來很簡潔,需要的朋友可以參考下

EnumSet

當需要使用位運算時，可能你會如此定義

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

使用時進行與或運算。但是定義多了之后，會很亂、臃腫，編寫容易出錯。EnumSet可以實現(xiàn)類似的功能，且使用起來很簡潔。

示例

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為存儲的所有枚舉實例數(shù)組。

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)//判斷枚舉實例的數(shù)目
            return new RegularEnumSet<>(elementType, universe);
        else
            return new JumboEnumSet<>(elementType, universe);
    }

首先獲取枚舉的所有實例，具體過程參見上一篇博文。RegularEnumSet和JumboEnumSet為EnumSet的兩個實現(xiàn)類。

當枚舉中定義的實例數(shù)不大于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先調(diào)用noneOf獲得EnumSet（RegularEnumSet或JumboEnumSet），allAll是個抽象方法，看下RegularEnumSet中是如何實現(xiàn)的

//RegularEnumSet.java
private long elements = 0L;
void addAll() {
        if (universe.length != 0)
            elements = -1L >>> -universe.length;
}

elements代表了EnumSet中存儲的所有枚舉實例所代表的bit數(shù)。示例中存儲了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方法有好幾個，參數(shù)不同罷了。這里指只說單元素的情況。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
    }
}

當枚舉有方法實現(xiàn)時，此時相當于內(nèi)部類，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;//兩者不等時取父類
    }

說回來，獲取類型之后，調(diào)用noneOf。調(diào)用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并沒有覆寫，而是交給兩個子類去實現(xiàn)的。

//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最終算的就是枚舉值對應的比特位是否被置位。