Java 文档 - EnumMap/EnumSet

简介

一般来说我们会选择使用HashMap来存储key-value格式的数据，考虑这样的特殊情况，一个HashMap的key都来自于一个Enum类，这样的情况则可以考虑使用本文要讲的EnumMap。

EnumMap

先看一下EnumMap的定义和HashMap定义的比较：

public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>
    implements java.io.Serializable, Cloneable

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable 

我们可以看到EnumMap几乎和HashMap是一样的，区别在于EnumMap的key是一个Enum。EnumMap是专门为枚举类型量身定做的Map实现。

下面看一个简单的使用的例子：

先定义一个Enum：

public enum Types {
    RED, GREEN, BLACK, YELLO
}

再看下怎么使用EnumMap：

    @Test
    public void useEnumMap(){
        EnumMap<Types, String> activityMap = new EnumMap<>(Types.class);
        activityMap.put(Types.BLACK,"black");
        activityMap.put(Types.GREEN,"green");
        activityMap.put(Types.RED,"red");
    }

EnumMap 源码

public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>
    implements java.io.Serializable, Cloneable {

    // 枚举类的class对象，例如示例的Color.class
    private final Class<K> keyType;

    // 存储key的数组，key即枚举类的值对象，包括了name和ordinal两个属性
    private transient K[] keyUniverse;

    // 存储value的数组，value允许null，null会被转换成Object NULL实例替代存储
    private transient Object[] vals;

    private transient int size = 0;

    // Object的实例，用于代表null，用于区分值数组中元素本身是null(还未存值)，
    // 还是存储的就是null值(已经存值)
    private static final Object NULL = new Object() {
        public int hashCode() {
            return 0;
        }

        public String toString() {
            return "java.util.EnumMap.NULL";
        }
    };

    private Object maskNull(Object value) {
        return (value == null ? NULL : value);
    }

    @SuppressWarnings("unchecked")
    private V unmaskNull(Object value) {
        return (V)(value == NULL ? null : value);
    }

    // 其他省略
}

EnumMap的基本操作都比较快，都在常量时间内完成

put()

public V put(K key, V value) {
    typeCheck(key);

    int index = key.ordinal();
    Object oldValue = vals[index];
    vals[index] = maskNull(value);
    if (oldValue == null)
        size++;
    return unmaskNull(oldValue);
}

private void typeCheck(K key) {
    Class<?> keyClass = key.getClass();
    if (keyClass != keyType && keyClass.getSuperclass() != keyType)
        throw new ClassCastException(keyClass + " != " + keyType);
}

public V get(Object key) {
    return (isValidKey(key) ?
            unmaskNull(vals[((Enum<?>)key).ordinal()]) : null);
}
private boolean isValidKey(Object key) {
    if (key == null)
        return false;

    // Cheaper than instanceof Enum followed by getDeclaringClass
    Class<?> keyClass = key.getClass();
    return keyClass == keyType || keyClass.getSuperclass() == keyType;
}

什么时候使用EnumMap

因为在EnumMap中，所有的key的可能值在创建的时候已经知道了，所以使用EnumMap和hashMap相比，可以提升效率。

同时，因为key比较简单，所以EnumMap在实现中，也不需要像HashMap那样考虑一些复杂的情况。

下面的代码给出了很清楚的解释：

private transient Object[] vals;
public V put(K key, V value) {
// ...
int index = key.ordinal();
vals[index] = maskNull(value);
// ...
}

上段代码的关键实现在于，我们用数组代替了哈希表。尤其是向map中插入新值时，所要做的仅仅是获得一个由编译器为每个枚举类型生成的常量序列号。如果有一个全局的map配置（例如只有一个实例），在增加访问速度的压力下，EnumMap 会获得比 HashMap 更加杰出的表现。原因在于 EnumMap 使用的堆内存比 HashMap 要少 一位（bit），而且 HashMap 要在每个键值上都要调用 hashCode() 方法和 equals() 方法。

EnumSet

跟EnumMap很类似，EnumSet是一个set，然后set中的元素都是某个Enum类型。

EnumSet是一个抽象类，要创建EnumSet类可以使用EnumSet提供的两个静态方法，noneOf和allOf。

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>
    implements Cloneable, java.io.Serializable
{
    // 保存的数据类型
    final Class<E> elementType;
    // 保存数据的数组
    final Enum<?>[] universe;
}

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);
    }

noneOf传入一个Enum类，返回一个空的Enum类型的EnumSet。

从上面的代码我们可以看到EnumSet有两个实现，长度大于64的时候使用JumboEnumSet，小有64的时候使用RegularEnumSet。

注意，JumboEnumSet和RegularEnumSet不建议直接使用，他是内部使用的类。

allOf()

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

/**
 * 创建一个EnumSet，从指定集合拷贝数据
 */
public static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c) {
    // 判断如果集合类型是EnumSet类型，则调用clone方法拷贝
    if (c instanceof EnumSet) {
        return ((EnumSet<E>)c).clone();
    } else {
        // 如果集合是空，直接抛异常
        if (c.isEmpty())
            throw new IllegalArgumentException("Collection is empty");
        // 通过Iterator迭代器实现拷贝
        Iterator<E> i = c.iterator();
        E first = i.next();
        EnumSet<E> result = EnumSet.of(first);
        while (i.hasNext())
            result.add(i.next());
        return result;
    }
}

public static <E extends Enum<E>> EnumSet<E> complementOf(EnumSet<E> s) {
    EnumSet<E> result = copyOf(s);
    result.complement();
    return result;
}

public static void main(String[] args) {
    EnumSet enumSet = EnumSet.of(Flag.RIGHT, Flag.ERROR);
    System.out.println(enumSet);

    EnumSet set = EnumSet.complementOf(enumSet);
    System.out.println(set);
}

public static <E extends Enum<E>> EnumSet<E> range(E from, E to) {
    if (from.compareTo(to) > 0)
        throw new IllegalArgumentException(from + " > " + to);
    EnumSet<E> result = noneOf(from.getDeclaringClass());
    result.addRange(from, to);
    return result;
}

总结

EnumMap和EnumSet对特定的Enum对象做了优化，在特定的的情况下，性能可以获得提升。

而EnumMap是专门为枚举类型量身定做的Map实现。虽然使用其它的Map实现（如HashMap）也能完成枚举类型实例到值得映射，但是使用EnumMap会更加高效：它只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以EnumMap使用数组来存放与枚举类型对应的值。这使得EnumMap的效率非常高。EnumMap在内部使用枚举类型的ordinal()得到当前实例的声明次序，并使用这个次序维护枚举类型实例对应值在数组的位置。