jdk1.8.0_45源碼解讀——HashMap的實現
一、HashMap概述
HashMap是基於哈希表的Map接口實現的,此實現提供所有可選的映射操作。存儲的是<key，value>對的映射，允許多個null值和一個null鍵。但此類不保證映射的順序，特別是它不保證該順序恆久不變。
除了HashMap是非同步以及允許使用null外，HashMap 類與 Hashtable大致相同。
此實現假定哈希函數將元素適當地分布在各桶之間，可為基本操作（get 和 put）提供穩定的性能。迭代collection 視圖所需的時間與 HashMap 實例的“容量”（桶的數量）及其大小（鍵-值映射關系數）成比例。所以，如果迭代性能很重要，則不要將初始容量設置得太高（或將加載因子設置得太低）。
HashMap 的實例有兩個參數影響其性能：初始容量 和加載因子。容量 是哈希表中桶的數量，初始容量只是哈希表在創建時的容量。加載因子 是哈希表在其容量自動增加之前可以達到多滿的一種尺度。當哈希表中的條目數超出了加載因子與當前容量的乘積時，則要對該哈希表進行 rehash 操作（即重建內部數據結構），從而哈希表將具有大約兩倍的桶數。
通常，默認加載因子 (0.75) 在時間和空間成本上尋求一種折衷。加載因子過高雖然減少了空間開銷，但同時也增加了查詢成本（在大多數 HashMap 類的操作中，包括 get 和 put 操作，都反映了這一點）。在設置初始容量時應該考慮到映射中所需的條目數及其加載因子，以便最大限度地減少 rehash 操作次數。如果初始容量大於最大條目數除以加載因子，則不會發生 rehash 操作。
注意，此實現不是同步的。 如果多個線程同時訪問一個HashMap實例，而其中至少一個線程從結構上修改了列表，那么它必須保持外部同步。這通常是通過同步那些用來封裝列表的 對象來實現的。但如果沒有這樣的對象存在，則應該使用{@link Collections#synchronizedMap Collections.synchronizedMap}來進行“包裝”，該方法最好是在創建時完成，為了避免對映射進行意外的非同步操作。
Map m = Collections.synchronizedMap(new HashMap(...));
二、HashMap的數據結構
HashMap實際上是一個“鏈表的數組”的數據結構，每個元素存放鏈表頭結點的數組，即數組和鏈表的結合體。
從上圖中可以看出，HashMap底層就是一個數組結構，數組中的每一項又是一個鏈表，鏈表中的每個元素為一個包含可以值，key哈希碼，value值的Node節點。該數組的下標索引為key的哈希碼。
三、HashMap源碼解析
1.映射項Node<K,V>結構
//實現Map.Entry<K,V>接口 static class Node<K,V> implements Map.Entry<K,V> { final int hash; //hash碼 final K key; V value; Node<K,V> next; //指向鏈表中下一個實例 Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } //返回此映射項的哈希值:key值的哈希碼與value值的哈希碼按位異或的結果 public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } //用指定值替換對應於此項的值,並返回舊值 public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } //比較指定對象與此項的相等性 public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry<?,?> e = (Map.Entry<?,?>)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }
2. HashMap類結構
//通過HahMap實現的接口可知，其支持所有映射操作，能被克隆，支持序列化 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { private static final long serialVersionUID = 362498820763181265L; //默認初始容量16，必須為2的冪 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 //最大容量 static final int MAXIMUM_CAPACITY = 1 << 30; //默認加載因子 static final float DEFAULT_LOAD_FACTOR = 0.75f; //table是一個Node<K,V>[]數組類型，而Node<K,V>實際上就是一個元素值為<key,value>對的單向鏈表。 //哈希表的"key-value鍵值對"都是存儲在Node<K,V>數組中的。 transient Node<K,V>[] table; //用來指向entrySet()返回的set集合 transient Set<Map.Entry<K,V>> entrySet; //HashMap的大小,即保存的鍵值對的數量 transient int size; //用來實現fail-fast機制的，記錄HashMap結構化修改的次數 transient int modCount; //下次需擴容的臨界值，size>=threshold就會擴容 //如果table數組沒有被分配，則該值為初始容量值16；或若該值為0，也表明該值為初始容量值 int threshold; //加載因子 final float loadFactor; ...... }
HashMap包含了幾個重要的成員變量：table, size, threshold, loadFactor。
(01) table是一個Node[]數組類型，而Node實際上就是一個單向鏈表。哈希表的"key-value鍵值對"都是存儲在Node數組中的。
(02) size是HashMap的大小，它是HashMap保存的鍵值對的數量。
(03) threshold是HashMap的閾值，用於判斷是否需要調整HashMap的容量。threshold的值="容量*加載因子"，當HashMap中存儲數據的數量達到threshold時（size>=threshold），就需要將HashMap的容量加倍。
(04) loadFactor就是加載因子。
注意：HashMap的數據結構和沖突處理方法？
通過HashMap數據存儲數組Node<K,V>[] table，及數據節點Node<K,V>的數據結構可知：HashMap是實現"key-value鍵值對"的映射關系的，是通過“拉鏈法”解決哈希沖突的。簡單的構造圖如下所示：
3. 構造函數
HashMap提供了四種方式的構造器，可以構造一個帶指定初始容量和加載因子的空HashMap，構造一個帶指定初始容量和默認加載因子(0.75)的空 HashMap，構造一個默認初始容量為16和默認加載因子為0.75的空HashMap，以及構造一個包含指定Map的元素的HashMap，容量與指定Map容量相同，加載因子為默認的0.75。
//找出“大於Capacity”的最小的2的冪,使Hash表的容量保持為2的次方倍 //算法的思想：通過使用邏輯運算來替代取余，這里有一個規律，就是當N為2的次方（Power of two），那么X％N==X&(N-1)。 static final int tableSizeFor(int cap) { int n = cap - 1; n |= n >>> 1; //>>> 無符號右移,高位補0 n |= n >>> 2; //a|=b的意思就是把a和b按位或然后賦值給a n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; } //構造一個帶指定初始容量和加載因子的空HashMap public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity); } //構造一個帶指定初始容量和默認加載因子(0.75)的空 HashMap public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } //構造一個具有默認初始容量 (16)和默認加載因子 (0.75)的空 HashMap public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } //構造一個映射關系與指定 Map相同的新 HashMap,容量與指定Map容量相同，加載因子為默認的0.75 public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }
4.resize()方法
在HashMap的四種構造函數中並沒有對其成員變量Node<K,V>[] table進行任何初始化的工作，那么HashMap是如何構造一個默認初始容量為16的空表的？該初始化的誘發條件是在向HashMap中添加第一對<key,value>時，通過put(K key, V value) -> putVal(hash(key), key, value, false, true) -> resize()方法。故HashMap中尤其重要的resize()方法主要實現了兩個功能：
1.在table數組為null時，對其進行初始化，默認容量為16；
2.當tables數組非空，但需要調整HashMap的容量時，將hash表容量翻倍。
//resize()方法作用有兩種：1.初始化hash表的容量，為16； 2.將hash表容量翻倍 final Node<K,V>[] resize() { Node<K,V>[] oldTab = table; //舊hash表 int oldCap = (oldTab == null) ? 0 : oldTab.length; //舊hash表容量 int oldThr = threshold; //舊hash表閾值 int newCap, newThr = 0; //新hash表容量與擴容臨界值 //2.舊hash表非空，則表容量翻倍 if (oldCap > 0) { //如果當前的hash表長度已經達到最大值，則不在進行調整 if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } //更新新hash表容量：翻倍 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) //更新擴容臨界值 newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; //1. 初始化hash表容量，設為默認值16 else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) //創建一個初始容量為新hash表長度的newTab數組 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab; //如果舊hash表非空，則按序將舊hash表中的元素重定向到新hash表 if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; //e按序指向oldTab數組中的元素，即每個鏈表中的頭結點 if ((e = oldTab[j]) != null) { oldTab[j] = null; if (e.next == null) //如果鏈表只有一個頭節點 newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode) ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); //對鏈表進行秩序維護：因為我們使用的是兩倍擴容的方法，所以每個桶里面的元素必須要么待在原來的 //索引所對應的位置，要么在新的桶中位置偏移兩倍 else { Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
5.查找
HashMap提供了get(Object key)、containsKey(Object key)、containsValue(Object value)這些查找鍵值對的方法。
//返回指定key所映射的value；如果對於該鍵來說，此映射不包含任何映射關系，則返回 null public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { //key的哈希值為數組下標 if (first.hash == hash && //檢查第一個節點 ((k = first.key) == key || (key != null && key.equals(k)))) return first; //如果第一個節點不對，則向后檢查 if ((e = first.next) != null) { if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key); do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; } //如果此映射包含對於指定鍵的映射關系，則返回 true。 public boolean containsKey(Object key) { return getNode(hash(key), key) != null; } //如果此映射將一個或多個鍵映射到指定值，則返回 true。 public boolean containsValue(Object value) { Node<K,V>[] tab; V v; if ((tab = table) != null && size > 0) { //外層循環搜索數組 for (int i = 0; i < tab.length; ++i) { //內層循環搜索鏈表 for (Node<K,V> e = tab[i]; e != null; e = e.next) { if ((v = e.value) == value || (value != null && value.equals(v))) return true; } } } return false; }
6.添加
HashMap提供了put(K key, V value)、putAll(Map<? extends K, ? extends V> m)這些添加鍵值對的方法。
/** * 在此映射中關聯指定值與指定鍵。如果該映射以前包含了一個該鍵的映射關系，則舊值被替換。 * * @param key 指定值將要關聯的鍵 * @param value 指定鍵將要關聯的值 * @return 與 key關聯的舊值；如果 key沒有任何映射關系，則返回 null。（返回 null 還可能表示該映射之前將null與 key關聯。） */ public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } /** * 用於實現 Map.put()和相關的方法 * * @param hash 鍵的hash碼 * @param key 鍵 * @param value 值 * @param onlyIfAbsent if true, don't change existing value * @param evict evict=false：表明該hash表處於初始化創建的過程中 * @return previous value, or null if none */ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //此處分兩種情況：1.當table為null時，用默認容量16初始化table數組；2.當table非空時 if ((tab = table) == null || (n = tab.length) == 0) //舊hash表為null或舊hash表長度為0 n = (tab = resize()).length; //初始化hash表的長度（16） //此處又分為兩種情況：1.key的hash值對應的那個節點為空；2.key的hash值對應的那個節點不為空 if ((p = tab[i = (n - 1) & hash]) == null) //該key的hash值對應的那個節點為空，即表示還沒有元素被散列至此 tab[i] = newNode(hash, key, value, null); //則創建一個新的new Node<>(hash, key, value, next); else { //該key的hash值對應的那個節點不為空，先與鏈表上的第一個節點p比較 Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; //向后查找 } } //若該key對應的value已經存在，則用新的value取代舊的value if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) //如果加入該鍵值對后超過最大閥值，則進行resize操作 resize(); afterNodeInsertion(evict); return null; } //將指定映射的所有映射關系復制到此映射中，這些映射關系將替換此映射目前針對指定映射中所有鍵的所有映射關系。 public void putAll(Map<? extends K, ? extends V> m) { putMapEntries(m, true); } //用於幫助實現Map.putAll()方法 和Map構造器，當evict=false時表示構造初始HashMap。 final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) { int s = m.size(); //得到指定Map的大小 if (s > 0) { if (table == null) { // pre-size float ft = ((float)s / loadFactor) + 1.0F; int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); //得到按指定Map大小計算出的HashMap所需的容量 if (t > threshold) //如果容量大於閾值 threshold = tableSizeFor(t); } else if (s > threshold) //指定Map的大小>擴容臨界值,擴容 resize(); //通過迭代器，將“m”中的元素逐個添加到HashMap中 for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { K key = e.getKey(); V value = e.getValue(); putVal(hash(key), key, value, false, evict); } } }
7.清空與刪除
HashMap提供了remove(Object key)刪除鍵值對、clear()清除所有鍵值對的方法。
//從此映射中移除指定鍵的映射關系（如果存在） public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } /** * 用於實現 Map.remove()方法和其他相關的方法 * * @param hash 鍵的hash值 * @param key 鍵 * @param value the value to match if matchValue, else ignored * @param matchValue if true only remove if value is equal * @param movable if false do not move other nodes while removing * @return the node, or null if none */ final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; //table數組非空，鍵的hash值所指向的數組中的元素非空 if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; //node指向最終的結果結點，e為鏈表中的遍歷指針 if (p.hash == hash && //檢查第一個節點，如果匹配成功 ((k = p.key) == key || (key != null && key.equals(k)))) node = p; //如果第一個節點匹配不成功，則向后遍歷鏈表查找 else if ((e = p.next) != null) { if (p instanceof TreeNode) node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { if (node instanceof TreeNode) ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p) //刪除node結點 tab[index] = node.next; else p.next = node.next; ++modCount; --size; afterNodeRemoval(node); return node; } } return null; } //從此映射中移除所有映射關系 public void clear() { Node<K,V>[] tab; modCount++; if ((tab = table) != null && size > 0) { size = 0; for (int i = 0; i < tab.length; ++i) tab[i] = null; } }
8.其他公開的方法
size()、isEmpty()、clone()
//返回此映射中的鍵-值映射關系數 public int size() { return size; } //如果此映射不包含鍵-值映射關系，則返回 true public boolean isEmpty() { return size == 0; } //返回此 HashMap 實例的淺表副本 public Object clone() { HashMap<K,V> result; try { result = (HashMap<K,V>)super.clone(); //調用父類clone方法 } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(e); } result.reinitialize(); result.putMapEntries(this, false); //將此HashMap元素放入result中 return result; }
支持序列化的寫入函數writeObject(java.io.ObjectOutputStream s)和讀取函數readObject(java.io.ObjectInputStream s)：
//java.io.Serializable的寫入函數,將HashMap的“總的容量，實際容量，所有的Entry”都寫入到輸出流中 private void writeObject(java.io.ObjectOutputStream s) throws IOException { int buckets = capacity(); // Write out the threshold, loadfactor, and any hidden stuff s.defaultWriteObject(); s.writeInt(buckets); s.writeInt(size); internalWriteEntries(s); } //java.io.Serializable的讀取函數：根據寫入方式讀出,將HashMap的“總的容量，實際容量，所有的Entry”依次讀出 private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { // Read in the threshold (ignored), loadfactor, and any hidden stuff s.defaultReadObject(); reinitialize(); if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new InvalidObjectException("Illegal load factor: " + loadFactor); s.readInt(); // Read and ignore number of buckets int mappings = s.readInt(); // Read number of mappings (size) if (mappings < 0) throw new InvalidObjectException("Illegal mappings count: " + mappings); else if (mappings > 0) { // (if zero, use defaults) // Size the table using given load factor only if within // range of 0.25...4.0 float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f); float fc = (float)mappings / lf + 1.0f; int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ? DEFAULT_INITIAL_CAPACITY : (fc >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : tableSizeFor((int)fc)); float ft = (float)cap * lf; threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ? (int)ft : Integer.MAX_VALUE); @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] tab = (Node<K,V>[])new Node[cap]; table = tab; // Read the keys and values, and put the mappings in the HashMap for (int i = 0; i < mappings; i++) { @SuppressWarnings("unchecked") K key = (K) s.readObject(); @SuppressWarnings("unchecked") V value = (V) s.readObject(); putVal(hash(key), key, value, false, false); } } } // Called only from writeObject, to ensure compatible ordering. void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException { Node<K,V>[] tab; if (size > 0 && (tab = table) != null) { for (int i = 0; i < tab.length; ++i) { for (Node<K,V> e = tab[i]; e != null; e = e.next) { s.writeObject(e.key); s.writeObject(e.value); } } }
四、HashMap的鍵集、值集和鍵值對集
HashMap是一個很有用的集合框架，通過下述三個方法可以分別得到HashMap的鍵集、值集和鍵值對集。
鍵集：Set<K> keySet()
值集：Collection<K> values()
鍵值對集：Set<Map.Entry<K,V>> entrySet()
得到這三種collection 視圖后，可以使用Iterator迭代器進行遍歷。
【感謝】
Java 集合系列10之 HashMap詳細介紹(源碼解析)和使用示例
深入Java集合學習系列：HashMap的實現原理