enum总结

1. 基本方法：

values: 可以遍历enum实例，返回enum实例的数组。

ordinal: 返回int 值，enum实例在声明时的次序，从0开始。

getDeclaringClass：得到实例所属的enum类。

name: 返回实例声明时的名字，等价于toString.

valueOf: 根据名字返回响应的enum实例，是static方法，如果不存在该名字，则抛出异常。

创建Enum实例时，编译器会生成继承于java.lang.Enum的类

Enum类实现了Comparable 和Serializable接口。

Enum类不能被继承。

enum的内部定义构造器一般为private，即使不是private，也只能在enmu的内部创建enum实例。

例子：

enum specialData{PSPROFILECHECK("PowerSuite Profile Check"),DIFFAIRPORTCHECK("Different Airports Check"),TRAVLEDOCUMENT("Travel Document"),CALLCARDVALIDATE("Calling Card Validation");private String context;private String getContext(){return this.context;}private specialData(String Context){this.context = Context;}public String toString(){return this.context;}};

2. 特别的：

（1）enum 类继承于Enum类，但是Enum并没有values()方法。

原因：values()是由编译器自动添加的static方法，编译器同时还添加了只含有一个餐食的valueOf(Enum中的valueOf含有两个参数。)

（2）编译器会自动将enum类标记为final类

（3）Class中有个getEnumConstants()方法可以获取Enum的所有enum实例。

摘自《java 编程思想》

enum Explore{HERE,THERE}public class EnumReflection {public static Set<String> analyze(Class<?> enumClass){System.out.println("------Analyzing " + enumClass + "--------");System.out.println("Interface");for(Type t : enumClass.getGenericInterfaces()){System.out.println(t);}System.out.println("Base: " + enumClass.getSuperclass());System.out.println("Methods： ");Set<String> methods = new TreeSet<String>();for(Method m : enumClass.getMethods()){methods.add(m.getName());}System.out.println(methods);return methods;}public static void main(String[] args){Set<String> exploreMethods = analyze(Explore.class);Set<String> enumMethods = analyze(Enum.class);System.out.println("Explore.containsAll(Enum)?" + exploreMethods.containsAll(enumMethods));System.out.println("exploreMethods.removeAll(enumMethods)");exploreMethods.removeAll(enumMethods);System.out.println(exploreMethods);OsExecute.command("javap Explore");}}

3. Enum VS EnumSet：

（1）Enum是不能添加删除的Set，和Set一样成员唯一。

（2）EnumSet的原理：位向量，位向量能表示的元素个数与向量长度有关，一个byte可以表示8个元素，一个long型可以表示64个元素。

（3）EnumSet源码：

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>implements Cloneable, java.io.Serializable{ final Class<E> elementType;//类型信息 final Enum<?>[] universe;//所有的枚举 private static Enum<?>[] ZERO_LENGTH_ENUM_ARRAY = new Enum<?>[0]; EnumSet(Class<E>elementType, Enum<?>[] universe) {        this.elementType = elementType;        this.universe    = universe;    } 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);    }  public static <E extends Enum<E>> EnumSet<E> allOf(Class<E> elementType) {        EnumSet<E> result = noneOf(elementType);        result.addAll();        return result;    }  abstract void addAll();  public static <E extends Enum<E>> EnumSet<E> copyOf(EnumSet<E> s) {        return s.clone();    }     /**     * Returns all of the values comprising E.     * The result is uncloned, cached, and shared by all callers.     */    private static <E extends Enum<E>> E[] getUniverse(Class<E> 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 <E extends Enum<E>>        implements java.io.Serializable    {        /**         * The element type of this enum set.         *         * @serial         */        private final Class<E> elementType;        /**         * The elements contained in this enum set.         *         * @serial         */        private final Enum<?>[] elements;        SerializationProxy(EnumSet<E> set) {            elementType = set.elementType;            elements = set.toArray(ZERO_LENGTH_ENUM_ARRAY);        }        // instead of cast to E, we should perhaps use elementType.cast()        // to avoid injection of forged stream, but it will slow the implementation        @SuppressWarnings("unchecked")        private Object readResolve() {            EnumSet<E> 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可以存储多于64个的元素。

所谓的add就是将对应元素设置为1，再与原来的值相或。

优点：节省空间，比Set效率高。

4.EnumMap

和Map的差别就是EnumMap的key值必须来源于enum类型，并且EnumMap保证顺序。