前言
书接上文，上一篇中对 EnumSet 进行了介绍与分析，本篇将对 EnumMap 进行介绍与分析。
首先还是来看一下 EnumMap 的继承关系图：
可以看到在继承关系图上与 EnumSet 是不同的，EnumMap 直接就是最终实现类了。
/**
* 一个特殊化给枚举类型键使用的的 {@link Map} 实现类。所有在一个 enum map 中的键s必须来自同一个指定的
* 枚举类型，显式的或者隐式的，在 map 被创建的时候。Enums 映射s在内部作为数组s被代表。这种表示方式是尤其
* 坚实和高效的。
*
* Enum maps 被它们的键s以自然顺序维护（就是 enum 常数被声明的顺序）。这在 迭代器s返回的 collections
* 视图s ({@link #keySet()}, {@link #entrySet()}, and {@link #values()}) 中被影响。
*
* 迭代器s返回的 collection 视图s是弱一致的：它们永远不会抛出 {@link
* ConcurrentModificationException} 并且它们可能或者不可能显示任何在迭代操作过程中修改 map 而出现的
* 影响。
*
* null 键s是不被允许的。属兔插入一个 null 键将抛出 {@link NullPointerException}。但是视图测试一个
* null 键或者移除一个，则不会。null 值s是允许的。
*
* 就像大多数 collection 的实现类s EnumMap 不是线程安全的。当多个线程并行地访问一个 enum map，并且至
* 少有一个线程修改了这个 map，它应该从外部被实现线程安全。这通常是通过对自然封装它的某个对象实现线程安全
* 完成的。如果不存在这样的对象，则这个 map 应该使用 {@link Collections#synchronizedMap} 方法来“包
* 装”。这最好实在创建的时候完成，来避免意外的线程不安全的方法：
*
* <pre>
* Map<EnumKey, V> m
* = Collections.synchronizedMap(new EnumMap<EnumKey, V>(...));
* </pre>
*
* 实现类注意：所有基本操作s都在常数时间内完成。它们看上去（虽然没有被保证）笔它们的 {@link HashMap} 对
* 应实现类更快。
*
* EnumMap 继承自 AbstractMap 抽象类，实现了 Serializable 接口与 Cloneable 接口
*/
public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V>
implements java.io.Serializable, Cloneable
{
/**
* 当前 map 所有键s的枚举类型类对象。
*
* @serial
*/
private final Class<K> keyType;
/**
* 所有包含 K 的值。（为了性能缓存。）类似于 EnumSet 中的 universe。
*/
private transient K[] keyUniverse;
/**
* 代表这个 map 的数组。ith 元素是 universe[i] 当前映射到的值，或者它没有映射到任何东西的话就会 null，或者它映射到 null 的话是 NULL。类似于 EnumSet 中的 elements。
*/
private transient Object[] vals;
/**
* 当前 map 中映射的数量。
*/
private transient int size = 0;
/**
* 对于代表 null 的值s区分非 null 值。
*/
private static final Object NULL = new Object() { //nullable 设计模式
public int hashCode() { //重写 hashCode
return 0; //对于值为 null 的元素，hash code 是 0
}
public String toString() { //重写 toString
return "java.util.EnumMap.NULL"; //对于值为 null 的元素
}
};
//掩盖 null 方法
private Object maskNull(Object value) {
return (value == null ? NULL : value); //nullable 设计模式，null =》 NULL
}
//掀开 null 方法
@SuppressWarnings("unchecked")
private V unmaskNull(Object value) {
return (V)(value == NULL ? null : value); //NULL =》 null
}
//与 EnumSet 一样有这个参数
private static final Enum<?>[] ZERO_LENGTH_ENUM_ARRAY = new Enum<?>[0];
/**
* 单参构造器，使用指定的键类型创建一个空的 enum map。
*/
public EnumMap(Class<K> keyType) {
//初始化
this.keyType = keyType;
keyUniverse = getKeyUniverse(keyType); //#getKeyUniverse
vals = new Object[keyUniverse.length];
}
/**
* 单参构造器，使用于指定 enum map 一样的键类型来创建一个 enum map，初始化包含相同的映射s（如果有的
* 话）。
*/
public EnumMap(EnumMap<K, ? extends V> m) {
//初始化
keyType = m.keyType;
keyUniverse = m.keyUniverse;
vals = m.vals.clone();
size = m.size;
}
/**
* 用一个指定 map 创建一个被初始化的 enum map。如果指定 map 是一个 EnumMap 实例，这个构造器与
* {@link #EnumMap(EnumMap)} 的行为相同。否则的话，指定 map 必须包含至少一个映射（为了定义新的
* enum map 的键类型）。
*/
public EnumMap(Map<K, ? extends V> m) {
if (m instanceof EnumMap) {
EnumMap<K, ? extends V> em = (EnumMap<K, ? extends V>) m;
//初始化
keyType = em.keyType;
keyUniverse = em.keyUniverse;
vals = em.vals.clone();
size = em.size;
} else { //如果参数不是 EnumMap 的实例
if (m.isEmpty())
throw new IllegalArgumentException("Specified map is empty");
keyType = m.keySet().iterator().next().getDeclaringClass();
keyUniverse = getKeyUniverse(keyType);
vals = new Object[keyUniverse.length];
putAll(m); //调用 AbstractMap#putAll
}
}
// 查询方法
/**
* 返回当前 map 中键值映射s的数量。
*/
public int size() {
return size;
}
/**
* 如果当前 map 有一个或多个键s映射到指定值，则返回 true。
*/
public boolean containsValue(Object value) {
value = maskNull(value); //#maskNull，使得 value 可以使用 equals 方法
for (Object val : vals) //循环 vals
if (value.equals(val))
return true; //如果存在 equals，返回 true
return false; //返回 false
}
/**
* 如果当前 map 包含一个指定键的映射，则返回 true。
*/
public boolean containsKey(Object key) {
return isValidKey(key) && vals[((Enum<?>)key).ordinal()] != null; //#isValidKey 并且 vals 中键的序号位置不为 null
}
//判断是否存在映射
private boolean containsMapping(Object key, Object value) {
return isValidKey(key) && //#isValidKey
maskNull(value).equals(vals[((Enum<?>)key).ordinal()]); //#maskNull 后调用 equals 与键的序号对应 vals 中位置值进行比较
}
/**
* 返回指定键映射到的值，如果当前 map 对这个键不包含映射则返回 {@code null}。
*
* 更正式地说，如果当前 map 存在一个 {@code (key == k)} 的键 {@code k} 到一个值 {@code v}，那么
* 这个方法返回 {@code v}，否则它返回 {@code null}。（至多只可能存在一个这样的映射。）
*
* 一个 {@code null} 返回值不是准确第说明这个 map 不包含这个键的映射，它也可能是这个 map 明确地将键
* 映射到了 {@code null}。{@link #containsKey containsKey} 操作可以用来区分这两种情况s。
*/
public V get(Object key) {
return (isValidKey(key) ? //#isValidKey
unmaskNull(vals[((Enum<?>)key).ordinal()]) : null); //对于 vals 键顺序位置的元素调用 #unmaskNull
}
// 修改操作s
/**
* 使用指定值与当前 map 中的指定键关联。如果 map 之前已经包含了这个键的一个映射，旧值将被替换。
*/
public V put(K key, V value) {
typeCheck(key);
int index = key.ordinal(); //获取键的序号
Object oldValue = vals[index]; //通过序号获取 vals 中的值
vals[index] = maskNull(value); //遮化参数值
if (oldValue == null) //如果旧值为 null
size++; //递增 size
return unmaskNull(oldValue); //返回掀化旧值
}
/**
* 如果当前 map 中包含这个键的映射，则移除。
*/
public V remove(Object key) {
if (!isValidKey(key)) //#isValidKey
return null;
int index = ((Enum<?>)key).ordinal(); //已经包含，获取序号
Object oldValue = vals[index]; //通过序号找到对应的值
vals[index] = null; //对应位置为 null
if (oldValue != null) //如果旧值不为 null
size--; //递减 size
return unmaskNull(oldValue); //返回掀化旧值
}
//删除映射
private boolean removeMapping(Object key, Object value) {
if (!isValidKey(key))
return false;
int index = ((Enum<?>)key).ordinal();
if (maskNull(value).equals(vals[index])) { //如果键存在，并且遮化参数 equals 键对应数组位置的值
vals[index] = null; //数组对应位置置为 null
size--; //递减 size
return true; //返回 true
}
return false; //返回 false
}
/**
* 如果键参数可以作为当前 enum map 的正确类型。
*/
private boolean isValidKey(Object key) {
if (key == null)
return false;
// 比 instanceOf 开销更小，Enum 跟在 getDeclaringClas 后面
Class<?> keyClass = key.getClass();
return keyClass == keyType || keyClass.getSuperclass() == keyType;
}
// 扩展操作
/**
* 从指定 map 中拷贝所有的映射s到当前 map。这些映射将替换当前 map 中任何在指定 map 中存在的键s的映射
* s。
*/
public void putAll(Map<? extends K, ? extends V> m) {
if (m instanceof EnumMap) {
EnumMap<?, ?> em = (EnumMap<?, ?>)m;
if (em.keyType != keyType) {
if (em.isEmpty())
return;
throw new ClassCastException(em.keyType + " != " + keyType);
}
for (int i = 0; i < keyUniverse.length; i++) { //循环数组
Object emValue = em.vals[i]; //缓存参数 EnumMap 数组指定位置的值
if (emValue != null) {
if (vals[i] == null) //如果当前 map 的数组指定位置为 null
size++; //递增 size
vals[i] = emValue; //当前 map 的数组指定位置赋值为 emValue
}
}
} else {
super.putAll(m); //参数 m 不是 EnumMap，调用 AbstarctMap#putAll
}
}
/**
* 移除当前 map 中的所有映射s
*/
public void clear() {
Arrays.fill(vals, null); //这个与 JumboEnumSet 的实现方式是相同的
size = 0;
}
// 视图s
/**
* 这个类属性是在第一次这个视图被请求时被初始化来包含一个 entry set 的实例视图的。这个视图是状态无关
* 的，所以不需要创建超过一个。
*/
private transient Set<Map.Entry<K,V>> entrySet;
/**
* 返回一个当前 map 中包含的键s的 {@link Set} 视图。返回的 set 遵守 {@link Map#keySet()} 概述的
* 一般规约。这个 set 的迭代器将以键s的自然顺序返回（也就是 enum 常数s声明的顺序）。
*/
public Set<K> keySet() {
Set<K> ks = keySet;
if (ks == null) {
ks = new KeySet(); //如果 keySet 为 null，调用 KeySet 构造器
keySet = ks;
}
return ks;
}
//EnumMap 的 KeySet 类，继承自 AbstractSet
private class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return new KeyIterator(); //调用 KeyIterator 构造器
}
public int size() {
return size; //返回 EnumMap 的 size
}
public boolean contains(Object o) {
return containsKey(o); //#containsKey
}
public boolean remove(Object o) {
int oldSize = size;
EnumMap.this.remove(o); //EnumMap#remove
return size != oldSize;
}
public void clear() {
EnumMap.this.clear(); //EnumMap#clear
}
}
/**
* 返回一个包含当前 map 中所有值的 {@link Collection} 视图。返回的 collection 遵循 {@link
* Map#values()} 中概述的一般规约。这个 collection 的迭代器将以值对应的键s在 map 中出现的顺序返回
* （也就是 enum 常数s被声明的顺序）。
*/
public Collection<V> values() {
Collection<V> vs = values;
if (vs == null) {
vs = new Values(); //调用 Values 构造器
values = vs;
}
return vs;
}
//EnumMap 的 Values 类，继承自 AbstractCollection
private class Values extends AbstractCollection<V> {
public Iterator<V> iterator() {
return new ValueIterator(); //调用 ValueIterator 构造器
}
public int size() {
return size; //返回 size
}
public boolean contains(Object o) {
return containsValue(o); //#containsValue
}
public boolean remove(Object o) {
o = maskNull(o); //遮化
for (int i = 0; i < vals.length; i++) { //循环数组
if (o.equals(vals[i])) { //确实有相同的
//移除，长度递减，返回 true
vals[i] = null;
size--;
return true;
}
}
return false;
}
public void clear() {
EnumMap.this.clear(); //EnumMap#clear
}
}
/**
* 返回一个包含了当前 map 中所有映射s的 {@link Set} 视图。返回的视图遵循 {@link Map#keySet()} 概
* 述的一般规约。这个 set 的迭代器将以键s在 map 中出现的顺序返回它们对应的映射s（也就是 enum 常数s被
* 声明的顺序）。
*/
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es = entrySet;
if (es != null)
return es;
else
return entrySet = new EntrySet(); //调用 EntrySet 构造器
}
//EntrySet 类，继承自 AbstractSet
private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return new EntryIterator(); //调用 EntryIterator 构造器
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> entry = (Map.Entry<?,?>)o;
return containsMapping(entry.getKey(), entry.getValue()); //#containsMapping
}
public boolean remove(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> entry = (Map.Entry<?,?>)o;
return removeMapping(entry.getKey(), entry.getValue()); //#removeMapping
}
public int size() {
return size; //返回 size
}
public void clear() {
EnumMap.this.clear(); //EmumMap#clear
}
public Object[] toArray() {
return fillEntryArray(new Object[size]); //#fillEntryArray
}
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
int size = size();
if (a.length < size)
a = (T[])java.lang.reflect.Array
.newInstance(a.getClass().getComponentType(), size);
if (a.length > size)
a[size] = null;
return (T[]) fillEntryArray(a); //#fillEntryArray
}
private Object[] fillEntryArray(Object[] a) {
int j = 0;
for (int i = 0; i < vals.length; i++) //循环 vals
if (vals[i] != null) //如果对应位置不为 null
a[j++] = new AbstractMap.SimpleEntry<>(
keyUniverse[i], unmaskNull(vals[i])); //参数数组位置递增，赋值为 AbstractMap.SimpleEntry 对象，键为 keyUniverse 中的对应键，值为 vals 中掀化值
return a;
}
}
//EnumMapIterator 类，实现了 Iterator 接口，可以看到 EnumMap 的对于迭代器这块的时候和其他 Map 最终实现类的迭代器还是类似的
private abstract class EnumMapIterator<T> implements Iterator<T> {
// 下一个要返回的更低的边界值
int index = 0;
// 上一个返回的元素的位置，或者如果没有的话就是 -1
int lastReturnedIndex = -1;
//判断游标后是否还有元素
public boolean hasNext() {
while (index < vals.length && vals[index] == null) //循环当 index 小于值容器长度并且置容器的 index 位置元素为 null 时候
/**
* 递增 index，直到 index >= 值容器长度或者置容器的 index 位置元素不为 null，这里需要
* 判断 index 位置元素是否为 null 的原因还是因为“单例”特性，remove 操作之后值容器数组
* 某位置的元素就置为 null 了，并且没有做任何数组前移的操作，也就不连续了
**/
index++;
return index != vals.length; //判断 index 是否等于等于置容器长度，返回结果
}
//移除方法
public void remove() {
checkLastReturnedIndex(); //#checkLastReturnedIndex
if (vals[lastReturnedIndex] != null) { //判断值容器 lastReturnedIndex 位置元素是否不为 null
vals[lastReturnedIndex] = null; //置为 null
size--; //递减 size
}
lastReturnedIndex = -1; //重置 lastReturnedIndex
}
//检查上一个返回值的位置方法
private void checkLastReturnedIndex() {
if (lastReturnedIndex < 0)
throw new IllegalStateException();
}
}
//EnumMap 的键迭代器，继承自 EnumMapIterator 抽象类
private class KeyIterator extends EnumMapIterator<K> {
//返回下一个键
public K next() {
if (!hasNext()) //#hasNext
throw new NoSuchElementException();
lastReturnedIndex = index++; //自增 index 后赋值给 lastReturnedIndex
return keyUniverse[lastReturnedIndex]; //返回键容器自增后的 lastReturnedIndex 位置的元素
}
}
//EnumMap 的值迭代器，继承自 EnumMapIterator 抽象类
private class ValueIterator extends EnumMapIterator<V> {
//返回下一个值
public V next() {
if (!hasNext()) //#hasNext
throw new NoSuchElementException();
/**
* 自增 index 后赋值给 lastReturnedIndex，这里与其他 Map 最终实现类不同，由于 EnumMap 维
* 护了键容器与值容器两个容器，它们共同组成了一个完整的条目，所以两个迭代器的 next 方法中
* lastReturnedIndex 要保持一致
**/
lastReturnedIndex = index++;
return unmaskNull(vals[lastReturnedIndex]); //返回值容器 lastReturnedIndex 位置的掀化
}
}
//EnumMap 的条目迭代器，继承自 EnumMapIterator 抽象类
private class EntryIterator extends EnumMapIterator<Map.Entry<K,V>> {
private Entry lastReturnedEntry; //多了一个上一个返回的条目属性，这个对象封装了 lastReturnedIndex
//返回下一个条目
public Map.Entry<K,V> next() {
if (!hasNext())
throw new NoSuchElementException();
lastReturnedEntry = new Entry(index++); //自增 index 后构造 Entry 对象
return lastReturnedEntry; //返回构造后的对象
}
//移除方法
public void remove() {
lastReturnedIndex =
((null == lastReturnedEntry) ? -1 : lastReturnedEntry.index); //如果 lastReturnedEntry 为 null 则重置 lastReturnedIndex，否则返回 lastReturnedEntry 的 index
super.remove(); //EnumMapIterator#remove
lastReturnedEntry.index = lastReturnedIndex; //lastReturnedIndex 赋值给 lastReturnedEntry 的 index
lastReturnedEntry = null; //重置 lastReturnedEntry
}
//Entry 类，实现了 Map.Entry 接口
private class Entry implements Map.Entry<K,V> {
private int index; //缓存一个 index 属性
//带参构造器，初始化 index
private Entry(int index) {
this.index = index;
}
//获取键
public K getKey() {
checkIndexForEntryUse(); //#checkIndexForEntryUse
return keyUniverse[index]; //返回键容器 index 位置的元素
}
//获取值
public V getValue() {
checkIndexForEntryUse(); //#checkIndexForEntryUse
return unmaskNull(vals[index]); //返回值容器 index 位置的元素
}
//设值
public V setValue(V value) {
checkIndexForEntryUse(); //#checkIndexForEntryUse
V oldValue = unmaskNull(vals[index]); //掀化值容器 index 位置的元素
vals[index] = maskNull(value); //遮化参数 value 并赋值给值容器 index 位置
return oldValue; //返回 oldValue
}
//equals
public boolean equals(Object o) {
if (index < 0)
return o == this;
if (!(o instanceof Map.Entry)) //判断参数只要是 Map.Entry 就行，这种设计应该是因为 EnumMap 的 Entry 类不会缓存键与值，这个还是因为"单例"特性
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
V ourValue = unmaskNull(vals[index]);
Object hisValue = e.getValue();
return (e.getKey() == keyUniverse[index] && //判断参数的键 == 键容器 index 位置的元素
(ourValue == hisValue || //判断参数的值 == 值容器掀化之
(ourValue != null && ourValue.equals(hisValue)))); //或者掀化值不为 unll 并且掀化值 equals 参数的值
}
//hashCode
public int hashCode() {
if (index < 0)
return super.hashCode(); //Object#hashCode
return entryHashCode(index); //#entryHashCode
}
//toString
public String toString() {
if (index < 0)
return super.toString();
return keyUniverse[index] + "="
+ unmaskNull(vals[index]);
}
//工具方法
private void checkIndexForEntryUse() {
if (index < 0)
throw new IllegalStateException("Entry was removed");
}
}
}
// 比较和哈希
/**
* 比较指定对象与当前 map 的相等性。如果指定对象也是一个 map 并且两个 maps 表示了相同的映射s，就像在
* {@link Map#equals(Object)} 规定的那样，则返回 true。
*/
public boolean equals(Object o) {
if (this == o)
return true;
if (o instanceof EnumMap)
return equals((EnumMap<?,?>)o);
if (!(o instanceof Map))
return false;
Map<?,?> m = (Map<?,?>)o;
if (size != m.size())
return false;
for (int i = 0; i < keyUniverse.length; i++) { //巡检键容器
if (null != vals[i]) { //如果值容器对应位置不为 null
K key = keyUniverse[i]; //获取键容器对应位置元素
V value = unmaskNull(vals[i]); //获取值容器对应元素掀化值
if (null == value) { //如果掀化之为 null
if (!((null == m.get(key)) && m.containsKey(key))) //如果参数 map 的键对应的值不为 null 或者参数 map 不包含键
return false; //返回 false
} else {
if (!value.equals(m.get(key))) //判断掀化值与参数 m 的键对应的值
return false;
}
}
}
return true;
}
//equals
private boolean equals(EnumMap<?,?> em) {
if (em.keyType != keyType)
return size == 0 && em.size == 0;
// 键类型符合，比较每一个值
for (int i = 0; i < keyUniverse.length; i++) { //循环键容器
Object ourValue = vals[i]; //找到值容器对应位置的值
Object hisValue = em.vals[i]; //找到参数的值容器对应位置的值
if (hisValue != ourValue &&
(hisValue == null || !hisValue.equals(ourValue))) //判断相等性
return false;
}
return true;
}
/**
* 返回当前 map 的 hash code。这个 map 的 hash code 被定义为每个 map 中的条目的 hash code 之和。
*/
public int hashCode() {
int h = 0;
for (int i = 0; i < keyUniverse.length; i++) {
if (null != vals[i]) {
h += entryHashCode(i);
}
}
return h;
}
//工具方法，每个条目的 hashCode
private int entryHashCode(int index) {
return (keyUniverse[index].hashCode() ^ vals[index].hashCode());
}
/**
* 返回当前 enum map 的浅拷贝。（值没有被克隆。）
*/
@SuppressWarnings("unchecked")
public EnumMap<K, V> clone() {
EnumMap<K, V> result = null;
try {
result = (EnumMap<K, V>) super.clone();
} catch(CloneNotSupportedException e) {
throw new AssertionError();
}
result.vals = result.vals.clone();
result.entrySet = null;
return result;
}
/**
* 工具方法。如果 e 不是当前 enum set 的一个正确的类型则抛出一个异常。
*/
private void typeCheck(K key) {
Class<?> keyClass = key.getClass();
if (keyClass != keyType && keyClass.getSuperclass() != keyType)
throw new ClassCastException(keyClass + " != " + keyType);
}
/**
* 返回包含 K 的所有值。返回结果是不可克隆的，缓存的，并且被所有调用者s分享的。
*/
private static <K extends Enum<K>> K[] getKeyUniverse(Class<K> keyType) {
return SharedSecrets.getJavaLangAccess()
.getEnumConstantsShared(keyType);
}
private static final long serialVersionUID = 458661240069192865L;
/**
* 序列化写方法，存储这个 EnumMap 实例的状态到一个流（比如序列化它）中。
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException
{
// 写出键类型和任何隐藏事物
s.defaultWriteObject();
// 写出长度（映射s的数量）
s.writeInt(size);
// 写出键s和值s（可轮流的）
int entriesToBeWritten = size; //缓存长度
for (int i = 0; entriesToBeWritten > 0; i++) { //循环写
if (null != vals[i]) {
s.writeObject(keyUniverse[i]);
s.writeObject(unmaskNull(vals[i]));
entriesToBeWritten--;
}
}
}
/**
* 序列化读方法，从一个流中重组 EnumMap 实例（比如反序列化它）。
*/
@SuppressWarnings("unchecked")
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException
{
// 读入键类型和任何隐藏事物
s.defaultReadObject();
keyUniverse = getKeyUniverse(keyType);
vals = new Object[keyUniverse.length];
// 读入长度（映射s的数量）
int size = s.readInt();
// 读入键s和值s，然后向 HashMap 中塞入映射s
for (int i = 0; i < size; i++) {
K key = (K) s.readObject();
V value = (V) s.readObject();
put(key, value);
}
}
}
通过 EnumMap 的源码可以看到，它与其他 Map 的最终实现类或者 EnumSet 的实现都不同，它维护了两个数组容器，一个键容器，一个值容器，这是处于 Enum 的“单例” 特性考虑的，它的条目中只有一个 index 属性，而 fillEntryArray 返回的数组中的条目是简单条目。两个容器的迭代器类在调用 next 方法之后都会更新 lastReturnedIndex 保持一致。keyUniverse 只有在初始化的时候才会指定长度，并同时对值容器进行初始化，由于 Enum 的“单例”特性，所以它的键其实是不会变更的，但是由于每一个 EnumMap 对象的“原型”特性，它的值容器是可以修改的，初始化之后对于 map 的 put 操作或者迭代器的 remove 操作都是对值容器进行更新，所以在 remove 之后会出现数组中的元素不连续的情况。
以上就是对于 EnumMap 的介绍与分析，下一篇将对 ArrayDeque 进行介绍与分析。
218
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
