阅读EnumSet抽象类源码

阅读EnumSet抽象类源码

EnumSet

EnumSet是java枚举类型的泛型容器，Java既然有了SortedSet、TreeSet、HashSet等容器，为何还要多一个EnumSet呢？答案肯定是EnumSet有一定的特性，举个例子，EnumSet的速度很快。其他特性就不一一列举了，毕竟本文的内容不是介绍EnumSet的特性。

专门为枚举类设计的集合类，所有元素必须是枚举类型

EnumSet的集合元素是有序的，内部以位向量的形成存储，因此占用内存小，效率高

不允许加入null元素

源码

package java.util;

import sun.misc.SharedSecrets;

public abstract class EnumSet> extends AbstractSet

implements Cloneable, java.io.Serializable

{

/**

* 元素类型

*/

final Class elementType;

/**

* 通过数组存储元素

*/

final Enum[] universe;

private static Enum[] ZERO_LENGTH_ENUM_ARRAY = new Enum[0];

EnumSet(ClasselementType, Enum[] universe) {

this.elementType = elementType;

this.universe = universe;

}

/**

* 创造一个空的 enum set 并制定其元素类型

* @param elementType the class object of the element type for this enum

* set

* @throws NullPointerException if elementType is null

*/

public static > EnumSet noneOf(Class 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);

}

/**

* 创建一个包含所有在指定元素类型的元素的枚举set

*

* @param elementType the class object of the element type for this enum

* set

* @throws NullPointerException if elementType is null

*/

public static > EnumSet allOf(Class elementType) {

EnumSet result = noneOf(elementType);

result.addAll();

return result;

}

/**

* Adds all of the elements from the appropriate enum type to this enum

* set, which is empty prior to the call.

*/

abstract void LEExVIaddAll();

/**

* 创建一个枚举设置相同的元素类型与指定枚举set

*

* @param s the enum set from which to initialize this enum set

* @throws NullPointerException if s is null

*/

public static > EnumSet copyOf(EnumSet s) {

return s.clone();

}

/**

* 创建一个枚举集从指定集合初始化，最初包含相同的元素

* @param c the collection from which to initialize this enum set

* @throws IllegalArgumentException if c is not an

* EnumSet instance and contains no elements

* @throws NullPointerException if c is null

*/

public static > EnumSet copyOf(Collection c) {

if (c instanceof EnumSet) {

return ((EnumSet)c).clone();

} else {

if (c.isEmpty())

throw new IllegalArgumentException("Collection is empty");

Iterator i = c.iterator();

E first = i.next();

EnumSet result = EnumSet.of(first);

while (i.hasNext())

result.add(i.next());

return result;

}

}

/**

* 创建一个枚举集合，其元素与 s 相同

* @param s the enum set from whose complement to initialize this enum set

* @throws NullPointerException if s is null

*/

public static > EnumSet complementOf(EnumSet s) {

EnumSet result = copyOf(s);

result.complement();

return result;

}

/**

* 1 个元素枚举集合

*

* @param e the element that this set is to contain initially

* @throws NullPointerException if e is null

* @return an enum set initially containing the specified element

*/

public static > EnumSet of(E e) {

EnumSet result = noneOf(e.getDeclaringClass());

result.add(e);

return result;

}

/**

* 2 个元素枚举集合

*

* @param e1 an element that this set is to contain initially

* @param e2 another element that this set is to contain initially

* @throws NullPointerException if any parameters are null

* @return an enum set initially containing the specified elements

*/

public static > EnumSet of(E e1, E e2) {

EnumSet result = noneOf(e1.getDeclaringClass());

result.add(e1);

result.add(e2);

return result;

}

/**

* 3 个元素枚举集合

*

* @param e1 an element that this set is to contain initially

* @param e2 another element that this set is to contain initially

* @param e3 another element that this set is to contain initially

* @throws NullPointerException if any parameters are null

* @return an enum set initially containing the specified elements

*/

public static > EnumSet of(E e1, E e2, E e3) {

EnumSet result = noneOf(e1.getDeclaringClass());

result.add(e1);

result.add(e2);

result.add(e3);

return result;

}

/**

* 4 个元素枚举集合

* @param e1 an element that this set is to contain initially

* @param e2 another element that this set is to contain initially

* @param e3 another element that this set is to contain initially

* @param e4 another element that this set is to contain initially

* @throws NullPointerException if any parameters are null

* @return an enum set initiallyhttp:// containing the specified elements

*/

public static > EnumSet of(E e1, E e2, E e3, E e4) {

EnumSet result = noneOf(e1.getDeclaringClass());

result.add(e1);

result.add(e2);

result.add(e3);

result.add(e4);

return result;

}

/**

* 5 个元素枚举集合

*

* @param e1 an element that this set is to contain initially

* @param e2 another element that this set is to contain initially

* @param e3 another element that this set is to contain initially

* @param e4 another element that this set is to contain initially

* @param e5 another element that this set is to contain initially

* @throws NullPointerException if any parameters are null

* @return an enum set initially containing the specified elements

*/

public static > EnumSet of(E e1, E e2, E e3, E e4,

E e5)

{

EnumSet result = noneOf(e1.getDeclaringClass());

result.add(e1);

result.add(e2);

result.add(e3);

result.add(e4);

result.add(e5);

return result;

}

/**

* n 个元素枚举集合

*

* @param first an element that the set is to contain initially

* @param rest the remaining elements the set is to contain initially

* @throws NullPointerException if any of the specified elements are null,

* or if rest is null

* @return an enum set initially containing the specified elements

*/

@SafeVarargs

public static > EnumSet of(E first, E... rest) {

EnumSet result = noneOf(first.getDeclaringClass());

result.add(first);

for (E e : rest)

result.add(e);

return result;

}

/**

* 区间内元素的 枚举集合

*

* @param from the first element in the range

* @param to the last element in the range

* @throws NullPointerException if {@code from} or {@code to} are null

* @throws IllegalArgumentException if {@code from.compareTo(to) > 0}

* @return an enum set initially containing all of the elements in the

* range defined by the two specified endpoints

*/

public static > EnumSet range(E from, E to) {

if (from.compareTo(to) > 0)

throw new IllegalArgumentException(from + " > " + to);

EnumSet result = noneOf(from.getDeclaringClass());

result.addRange(from, to);

return result;

}

/**

* Adds the specified range to this enum set, which is empty prior

* to the call.

*/

abstract void addRange(E from, E to);

/**

* Returns a copy of this set.

*

* @return a copy of this set

*/

public EnumSet clone() {

try {

return (EnumSet) super.clone();

} catch(CloneNotSupportedException e) {

throw new AssertionError(e);

}

}

/**

* Complements the contents of this enum set.

*/

abstract void complement();

/**

* Throws an exception if e is not of the correct type for this enum set.

*/

final void typeCheck(E e) {

Class eClass = e.getClass();

if (eClass != elementType && eClass.getSuperclass() != elementType)

throw new ClassCastException(eClass + " != " + elementType);

}

/**

* Returns all of the values comprising E.

* The result is uncloned, cached, and shared by all callers.

*/

private static > E[] getUniverse(Class elementType) {

return SharedSecrets.getJavaLangAccess()

.getEnumConstantsShared(elementType);

}

/**

* This class is used to serialize all EnumSet instances, regardless of

* implementation type. It captures their "logical contents" and they

* are reconstructed using public static factories. This is necessary

* to ensure that the existence of a particular implementation type is

* an implementation detail.

*

* @serial include

*/

private static class SerializationProxy >

implements java.io.Serializable

{

/**

* The element type of this enum set.

*

* @serial

*/

private final Class elementType;

/**

* The elements contained in this enum set.

*

* @serial

*/

private final Enum[] elements;

SerializationProxy(EnumSet set) {

elementType = set.elementType;

elements = set.toArray(ZERO_LENGTH_ENUM_ARRAY);

}

private Object readResolve() {

EnumSet result = EnumSet.noneOf(elementType);

for (Enum e : elements)

result.add((E)e);

return result;

}

private static final long serialVersionUID = 362491234563181265L;

}

Object writeReplace() {

return new SerializationProxy<>(this);

}

// readObject method for the serialization proxy pattern

// See Effective Java, Second Ed., Item 78.

private void readObject(java.io.ObjectInputStream stream)

throws java.io.InvalidObjectException {

throw new java.io.InvalidObjectException("Proxy required");

}

}

总结

以上就是本文关于阅读EnumSet抽象类源码的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。