1、EnumMap-源码分析-底层数据结构

  1. 1、EnumMap-源码分析-底层数据结构：
  2.     1-1、底层使用数组实现(K，V 双数组)，其key必须为Enum类型，两个数组，一个数组keyUniverse存储key，另一个数组vals存储val，两个数组通过下标对应起来。
  3.     1-2、key 数组会在构造函数中根据 keyType 进行初始化，当 EnmumMap的value为 null 时会特殊处理为一个 Object 对象。
  4. 2、EnumMap-主要属性有：
  5.     /**
  6.      * The <tt>Class</tt> object for the enum type of all the keys of this map.
  7.      *
  8.      * 所有kye的枚举类型的<tt>类</tt>对象
  9.      * @serial：连续的
  10.      */
  11.     private final Class<K> keyType;
  13.     /**
  14.      * All of the values comprising K.  (Cached for performance.)
  15.      *
  16.      * key的数组：包含Key的所有值（缓存以提高性能）
  17.      */
  18.     private transient K[] keyUniverse;
  20.     /**
  21.      * Array representation of this map.  The ith element is the value
  22.      * to which universe[i] is currently mapped, or null if it isn't
  23.      * mapped to anything, or NULL if it's mapped to null.
  24.      *
  25.      * value数组：如果没有映射，则为空，映射到任何对象，如果映射到NULL，则为NULL
  26.      */
  27.     private transient Object[] vals;
  29.     /**
  30.      * The number of mappings in this map.
  31.      *  键值对个数
  32.      */
  33.     private transient int size = 0;
  35.     /**
  36.      * Distinguished non-null value for representing null values.
  37.      *
  38.      * 用于表示null值的可分辨非空值：value 为 null 时对应的值【???】。
  39.      */
  40.     private static final Object NULL = new Object() {
  41.         public int hashCode() {
  42.             return 0;
  43.         }
  45.         public String toString() {
  46.             return "java.util.EnumMap.NULL";
  47.         }
  48.     };
  50.     /**
  51.      * 此枚举常量的序号(其位置在枚举声明中，初始常量被赋值零的序数)
  52.      */
  53.     private final int ordinal;
  55.     /**
  56.      * 返回此枚举常量的序号(其位置在其enum声明中，初始常量被赋值零的序数)
  57.      */
  58.     public final int ordinal() {
  59.         return ordinal;
  60.     }

2、EnumMap-源码分析-构造方法

  1. 1、EnumMap-源码分析-构造方法：EnumMap 共提供了 3 个构造函数
  3. 2、源代码：
  4.     /**
  5.      * 创建具有指定键类型的空枚举映射。
  6.      *
  7.      * @param keyType此枚举映射的键类型的类对象
  8.      * @throws 如果keyType为null，则@throws NullPointerException
  9.      */
  10.     public EnumMap(Class<K> keyType) {
  11.         this.keyType = keyType;
  12.         // 初始化 key 数组，getKeyUniverse 方法会计算出枚举元素的总数并初始化 key 数组
  13.         keyUniverse = getKeyUniverse(keyType);
  14.         // 初始化 value 数组大小
  15.         vals = new Object[keyUniverse.length];
  16.     }
  18.     /**
  19.      * 创建与指定枚举具有相同键类型的枚举映射
  20.      *
  21.      * @param m m从中初始化此枚举映射的枚举映射
  22.      * @throws NullPointerException if <tt>m</tt> is null
  23.      */
  24.     public EnumMap(EnumMap<K, ? extends V> m) {
  25.         keyType = m.keyType;
  26.         keyUniverse = m.keyUniverse;
  27.         vals = m.vals.clone();
  28.         size = m.size;
  29.     }
  31.     /**
  32.      * 创建从指定映射初始化的枚举映射。如果指定的映射是一个<tt>EnumMap</tt>实例
  33.      *
  34.      * @param m m从中初始化此枚举映射的映射
  35.      * @throws IllegalArgumentException if 如果<tt>m</tt>不是<tt>EnumMap</tt>实例
  36.      * @throws NullPointerException if <tt>m</tt> is null
  37.      */
  38.     public EnumMap(Map<K, ? extends V> m) {
  39.         if (m instanceof EnumMap) {
  40.             EnumMap<K, ? extends V> em = (EnumMap<K, ? extends V>) m;
  41.             keyType = em.keyType;
  42.             keyUniverse = em.keyUniverse;
  43.             vals = em.vals.clone();
  44.             size = em.size;
  45.         } else {
  46.             if (m.isEmpty())
  47.                 throw new IllegalArgumentException("Specified map is empty");
  48.             keyType = m.keySet().iterator().next().getDeclaringClass();
  49.             keyUniverse = getKeyUniverse(keyType);
  50.             vals = new Object[keyUniverse.length];
  51.             putAll(m);
  52.         }
  53.     }
  55. 3、构造方法中涉及的方法
  56.     /**
  57.      * 返回包含K的所有值，结果将被所有调用方取消锁定、缓存和共享。
  58.      */
  59.     private static <K extends Enum<K>> K[] getKeyUniverse(Class<K> keyType) {
  60.         //通过 JavaLangAccess 和 SharedSecrets 来获取 JVM 中对象实例
  61.         return SharedSecrets.getJavaLangAccess().getEnumConstantsShared(keyType);
  62.     }

3、EnumMap-源码分析-添加元素

  1. 1、EnumMap-源码分析-添加元素：.put()方法
  3. 2、源代码：
  4.     public V put(K key, V value) {
  5.         // key 类型检查,如果 key 的类型不一致会抛出异常(ClassCastException)。
  6.         typeCheck(key);
  8.         // 获得该 key 对应的位置
  9.         int index = key.ordinal();
  10.         // 在 vals 数组中获取 key 角标对应的 value
  11.         Object oldValue = vals[index];
  12.         // 覆盖或设置 value
  13.         vals[index] = maskNull(value);
  14.         // 如果 key 对应的位置 value 为 null，则表示新插入了键值对，size++，反之表示值覆盖 size 不变
  15.         if (oldValue == null)
  16.             size++;
  17.         return unmaskNull(oldValue);
  18.     }
  20.     //添加的 value 为 null 会通过 maskNull 方法特殊处理，存储一个 Object 对象。
  21.     private Object maskNull(Object value) {
  22.         return (value == null ? NULL : value);
  23.     }
  25.     //值覆盖的话，put 方法会返回旧的 value 值，并特殊处理 value 为 null 的情况：
  26.     private V unmaskNull(Object value) {
  27.         return (V)(value == NULL ? null : value);
  28.     }
  30. 3、添加元素方法-小结
  31.     3-1、EnmuMap 添加键值对并没有扩容操作，因为一个枚举类型到底有多少元素在代码运行阶段是确定的，在构造函数中已经对 key 数组进行了初始化与赋值，value 数组的大小也已经被确定。
  32.     3-2、还有一个需要注意的问题，在上面的 .put()方法中只对 value 进行了处理，并没有处理 key，原因就是 key 数组在构造函数中已经被赋值了。

4、EnumMap-源码分析-获取元素

  1. 1、EnumMap-源码分析-获取元素：.get()方法
  3. 2、源代码：
  4.     public V get(Object key) {
  5.         return (isValidKey(key) ?
  6.                 unmaskNull(vals[((Enum<?>)key).ordinal()]) : null);
  7.     }
  9.     //调用 isValidKey 方法对 key 进行一次检查
  10.     private boolean isValidKey(Object key) {
  11.         // key 为 null 直接返回 false
  12.         if (key == null)
  13.             return false;
  15.         // Cheaper than instanceof Enum followed by getDeclaringClass
  16.         Class<?> keyClass = key.getClass();
  17.         // key 类型检查
  18.         return keyClass == keyType || keyClass.getSuperclass() == keyType;
  19.     }
  21.     //特殊处理 value 为 null 的情况：
  22.     private V unmaskNull(Object value) {
  23.         return (V)(value == NULL ? null : value);
  24.     }
  26.     //EnumMap 存储键值对时并不会根据 key 获取对应的哈希值，enum 本身已经提供了一个 ordinal() 方法，该方法会返回具体枚举元素在枚举类中的位置（从 0 开始），因此一个枚举元素从创建就已经有了一个唯一索引与其对应，这样就不存在哈希冲突的问题了。

5、EnumMap-源码分析-删除元素

  1. 1、EnumMap-源码分析-删除元素：.remove()方法
  3. 2、源代码：
  4.     /**
  5.      * Removes the mapping for this key from this map if present.
  6.      *
  7.      * @param key the key whose mapping is to be removed from the map
  8.      * @return the previous value associated with specified key, or
  9.      *     <tt>null</tt> if there was no entry for key.  (A <tt>null</tt>
  10.      *     return can also indicate that the map previously associated
  11.      *     <tt>null</tt> with the specified key.)
  12.      */
  13.     public V remove(Object key) {
  14.         // key 类型错误的时候直接返回 null
  15.         if (!isValidKey(key))
  16.             return null;
  17.         // 根据 key 计算出其在枚举中位置
  18.         int index = ((Enum<?>)key).ordinal();
  19.         // 获取对应的 value
  20.         Object oldValue = vals[index];
  21.         // value 置 null，下次 GC 回收
  22.         vals[index] = null;
  23.         // 如果对应的 value 不为 null，如果添加键值对的时候 value 为 null，则存储的是 NULL（Object）
  24.         if (oldValue != null)
  25.             size--;
  26.         return unmaskNull(oldValue);
  27.     }
  29.     //调用 isValidKey 方法对 key 进行一次检查
  30.     private boolean isValidKey(Object key) {
  31.         // key 为 null 直接返回 false
  32.         if (key == null)
  33.             return false;
  35.         // Cheaper than instanceof Enum followed by getDeclaringClass
  36.         Class<?> keyClass = key.getClass();
  37.         // key 类型检查
  38.         return keyClass == keyType || keyClass.getSuperclass() == keyType;
  39.     }

6、EnumMap-源码分析-遍历元素

  1. 1、EnumMap-遍历元素：与Map遍历方式差不多
  3. 2、EnumMap-遍历元素-特殊之处：
  4.     //举例Demo
  5.     public static void main(String[] args) throws Exception {
  6.         EnumMap<Season, String> map = new EnumMap<>(Season.class);
  7.         // 获取迭代器对象
  8.         Iterator<Map.Entry<Season, String>> iterator = map.entrySet().iterator();
  10.         while (iterator.hasNext()) {
  11.             //并不会输出任何 key，原因就在于 EnumMap 的 hasNext() 方法中对 value 做了非空判断
  12.             System.out.println(iterator.next().getKey());
  13.         }
  14.     }
  16.     //尽管在构造函数中 key 数组已经被初始化，但是如果对应的 value 为 null，在迭代的时候也会被过滤掉。
  17.     //通过.hasNext()方法跳过空的数组
  18.     public boolean hasNext() {
  19.         // 循环中会略过 value 数组中为 null 的情况
  20.         while (index < vals.length && vals[index] == null)
  21.             index++;
  22.         return index != vals.length;
  23.     }
  25. 3、EnumMapIterator的迭代
  26.     private class EntryIterator extends EnumMapIterator<Map.Entry<K,V>> {
  27.         private Entry lastReturnedEntry;
  29.         public Map.Entry<K,V> next() {
  30.             //通过.hasNext()方法跳过空的数组
  31.             if (!hasNext())
  32.                 throw new NoSuchElementException();
  33.             lastReturnedEntry = new Entry(index++);
  34.             return lastReturnedEntry;
  35.         }
  37.         public void remove() {
  38.             lastReturnedIndex =
  39.                 ((null == lastReturnedEntry) ? -1 : lastReturnedEntry.index);
  40.             super.remove();
  41.             lastReturnedEntry.index = lastReturnedIndex;
  42.             lastReturnedEntry = null;
  43.         }
  45.         private class Entry implements Map.Entry<K,V> {
  46.             private int index;
  48.             private Entry(int index) {
  49.                 this.index = index;
  50.             }
  52.             public K getKey() {
  53.                 checkIndexForEntryUse();
  54.                 return keyUniverse[index];
  55.             }
  57.             public V getValue() {
  58.                 checkIndexForEntryUse();
  59.                 return unmaskNull(vals[index]);
  60.             }
  62.             public V setValue(V value) {
  63.                 checkIndexForEntryUse();
  64.                 V oldValue = unmaskNull(vals[index]);
  65.                 vals[index] = maskNull(value);
  66.                 return oldValue;
  67.             }
  69.             public boolean equals(Object o) {
  70.                 if (index < 0)
  71.                     return o == this;
  73.                 if (!(o instanceof Map.Entry))
  74.                     return false;
  76.                 Map.Entry<?,?> e = (Map.Entry<?,?>)o;
  77.                 V ourValue = unmaskNull(vals[index]);
  78.                 Object hisValue = e.getValue();
  79.                 return (e.getKey() == keyUniverse[index] &&
  80.                         (ourValue == hisValue ||
  81.                          (ourValue != null && ourValue.equals(hisValue))));
  82.             }
  84.             public int hashCode() {
  85.                 if (index < 0)
  86.                     return super.hashCode();
  88.                 return entryHashCode(index);
  89.             }
  91.             public String toString() {
  92.                 if (index < 0)
  93.                     return super.toString();
  95.                 return keyUniverse[index] + "="
  96.                     + unmaskNull(vals[index]);
  97.             }
  99.             private void checkIndexForEntryUse() {
  100.                 if (index < 0)
  101.                     throw new IllegalStateException("Entry was removed");
  102.             }
  103.         }
  104.     }