Java集合詳解（三）：HashMap原理解析

Yanci丶發表於2021-05-23
JavaHashMap

概述

　　本文是基於jdk8_271版本進行分析的。
　　HashMap是Map集合中使用最多的。底層是基於陣列+連結串列實現的，jdk8開始底層是基於陣列+連結串列/紅黑樹實現的。HashMap也會動態擴容，與ArrayList不同的是，HashMap有一個閾值欄位，元素數量達到閾值之後就會進行擴容。HashMap允許key為null。同時HashMap也是執行緒不安全的。

 資料結構

  • 實現繼承關係

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

  • 靜態變數

 1 /**
 2      * 預設初始化容量 16
 3      */
 4     static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
 5 
 6     /**
 7      * MUST be a power of two <= 1<<30.
 8      * 集合最大容量
 9      */
10     static final int MAXIMUM_CAPACITY = 1 << 30;
11 
12     /**
13      * 預設載入因子的值
14      */
15     static final float DEFAULT_LOAD_FACTOR = 0.75f;
16 
17     /**
18      * 連結串列上元素個數概率
19      * 0:    0.60653066
20      * 1:    0.30326533
21      * 2:    0.07581633
22      * 3:    0.01263606
23      * 4:    0.00157952
24      * 5:    0.00015795
25      * 6:    0.00001316
26      * 7:    0.00000094
27      * 8:    0.00000006
28      * 當連結串列的值數量大於8時，會從連結串列轉成紅黑樹
29      */
30     static final int TREEIFY_THRESHOLD = 8;
31 
32     /**
33      * 當連結串列的值數量小於6時，會從紅黑樹轉回連結串列
34      */
35     static final int UNTREEIFY_THRESHOLD = 6;
36 
37     /**
38      * 當Map中數量超過這個值才會轉成紅黑樹，否則優先進行擴容
39      */
40     static final int MIN_TREEIFY_CAPACITY = 64;

  • 靜態內部類

　　1.Node

 1     static class Node<K,V> implements Map.Entry<K,V> {
 2         final int hash; // hash值
 3         final K key;    // key
 4         V value;        // value
 5         Node<K,V> next; // 下一個節點
 6 
 7         Node(int hash, K key, V value, Node<K,V> next) {
 8             this.hash = hash;
 9             this.key = key;
10             this.value = value;
11             this.next = next;
12         }
13 
14         public final K getKey()        { return key; }
15         public final V getValue()      { return value; }
16         public final String toString() { return key + "=" + value; }
17 
18         public final int hashCode() {
19             return Objects.hashCode(key) ^ Objects.hashCode(value);
20         }
21 
22         public final V setValue(V newValue) {
23             V oldValue = value;
24             value = newValue;
25             return oldValue;
26         }
27 
28         public final boolean equals(Object o) {
29             if (o == this)
30                 return true;
31             if (o instanceof Map.Entry) {
32                 Map.Entry<?,?> e = (Map.Entry<?,?>)o;
33                 if (Objects.equals(key, e.getKey()) &&
34                     Objects.equals(value, e.getValue()))
35                     return true;
36             }
37             return false;
38         }
39     }

　　2.TreeNode

 1     static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
 2         TreeNode<K,V> parent;  // 父節點
 3         TreeNode<K,V> left;    // 左節點
 4         TreeNode<K,V> right;    //右節點
 5         TreeNode<K,V> prev;    // 上一個同級結點
 6         boolean red;
 7         TreeNode(int hash, K key, V val, Node<K,V> next) {
 8             super(hash, key, val, next);
 9         }
10     }

  • 成員變數

 1 　　transient Node<K,V>[] table;
 2 
 3     /**
 4      * for keySet() and values().
 5      */
 6     transient Set<Map.Entry<K,V>> entrySet;
 7 
 8     /**
 9      * 實際存放資料數量
10      */
11     transient int size;
12 
13     /**
14      * 修改次數
15      */
16     transient int modCount;
17 
18     /**
19      * 閾值。閾值=容量*載入因子；預設為16*0.75=12。當元素數量超過閾值便會觸發擴容。
20      */
21     int threshold;
22 
23     /**
24      * 載入因子，預設是0.75，一般使用預設值。
25      */
26     final float loadFactor;

  • 構造方法

　　HashMap採用的是懶載入方式，在新建物件時候不會初始化陣列，等使用時候才會去初始化。載入因子大多數情況都是使用預設值。容量值大小一定得是2的指數次冪，會根據傳入的容量值呼叫tableSizeFor()方法重新計算容量值大小。

 1     public HashMap(int initialCapacity, float loadFactor) {
 2         if (initialCapacity < 0)
 3             throw new IllegalArgumentException("Illegal initial capacity: " +
 4                                                initialCapacity);
 5         if (initialCapacity > MAXIMUM_CAPACITY)
 6             initialCapacity = MAXIMUM_CAPACITY;
 7         if (loadFactor <= 0 || Float.isNaN(loadFactor))
 8             throw new IllegalArgumentException("Illegal load factor: " +
 9                                                loadFactor);
10         this.loadFactor = loadFactor;
11         // 閾值，初始化時候是沒有*載入因子的。對給定的容量值重新計算，返回一個2的指數次冪的值。此時容量值大小為0。
12         this.threshold = tableSizeFor(initialCapacity);
13     }
14 
15     public HashMap(int initialCapacity) {
16         this(initialCapacity, DEFAULT_LOAD_FACTOR);
17     }
18 
19     public HashMap() {
20         this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
21         // 此時閾值和容量值大小都為0
22     }
23 
24     public HashMap(Map<? extends K, ? extends V> m) {
25         this.loadFactor = DEFAULT_LOAD_FACTOR;
26         putMapEntries(m, false);
27     }

主要方法解析

  • tableSizeFor--重新計算容量大小

 1     /**
 2      * 對於給定的目標容量，進行位運算。返回的值是2的指數冪（返回的是>=cap最小一個2的指數次冪）。
 3      */
 4     static final int tableSizeFor(int cap) {
 5         int n = cap - 1;
 6         n |= n >>> 1;
 7         n |= n >>> 2;
 8         n |= n >>> 4;
 9         n |= n >>> 8;
10         n |= n >>> 16;
11         return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
12     }

  • putMapEntries--新增一個map集合到該集合

 1     /**
 2      * Map.putAll，Map建構函式 會呼叫該方法
 3      *
 4      * @param m the map
 5      * @param evict 初始化有參構造時為false，其他為true
 6      */
 7     final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
 8         int s = m.size();
 9         // 如果傳入的集合大小=0不進行操作
10         if (s > 0) {
11             if (table == null) { // pre-size
12                 float ft = ((float)s / loadFactor) + 1.0F;
13                 int t = ((ft < (float)MAXIMUM_CAPACITY) ?
14                          (int)ft : MAXIMUM_CAPACITY);
15                 if (t > threshold)
16                     //
17                     threshold = tableSizeFor(t);
18             }
19             else if (s > threshold)
20                 // 如果table!=null && s>threshold，進行擴容處理
21                 resize();
22             for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
23                 K key = e.getKey();
24                 V value = e.getValue();
25                 putVal(hash(key), key, value, false, evict);
26             }
27         }
28     }

  • resize--擴容方法

 1     final Node<K,V>[] resize() {
 2         Node<K,V>[] oldTab = table;
 3         int oldCap = (oldTab == null) ? 0 : oldTab.length;  // 原容量值
 4         int oldThr = threshold; // 原閾值
 5         int newCap, newThr = 0;
 6         if (oldCap > 0) {
 7             if (oldCap >= MAXIMUM_CAPACITY) {
 8                 // 原容量大小已達到最大值，不進行擴容。同時將閾值設定為Integer.MAX_VALUE
 9                 threshold = Integer.MAX_VALUE;
10                 return oldTab;
11             }
12             else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
13                      oldCap >= DEFAULT_INITIAL_CAPACITY)
14                 // newCap新容量擴容為老容量的2倍
15                 // 如果原容量值大於等於預設值16，同時將新閾值擴容為原閾值的2倍
16                 newThr = oldThr << 1; // double threshold
17         }
18         else if (oldThr > 0) // 如果原容量等於0，原閾值大於0；這種情況為有參構造建立的物件，還未新增資料
19             // 將原閾值（此時原閾值就是之前計算的容量大小）賦值給新容量值，新閾值大小會在下面統一計算（此時新閾值大小為0）。
20             newCap = oldThr;
21         else {               // 如果原容量等於0，原閾值等於0；這種情況為無參構造建立的物件
22             // 則將新容量值大小設定為預設值16，新閾值大小設定為12
23             newCap = DEFAULT_INITIAL_CAPACITY;
24             newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
25         }
26         if (newThr == 0) {
27             // 如果新閾值大小為0，則會通過 新容量值大小*載入因子 計算，如果新容量值大小或者新閾值大小超出最大容量值，則將新閾值設定為Integer.MAX_VALUE
28             float ft = (float)newCap * loadFactor;
29             newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
30                       (int)ft : Integer.MAX_VALUE);
31         }
32         threshold = newThr;
33         @SuppressWarnings({"rawtypes","unchecked"})
34         Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
35         table = newTab;
36         if (oldTab != null) {
37             for (int j = 0; j < oldCap; ++j) {
38                 Node<K,V> e;
39                 if ((e = oldTab[j]) != null) {
40                     oldTab[j] = null;
41                     if (e.next == null) // 桶內只有一個元素
42                         newTab[e.hash & (newCap - 1)] = e;
43                     else if (e instanceof TreeNode) // 桶內元素是紅黑樹結構，呼叫split方法，完成舊陣列紅黑樹結構遷移到新陣列中的工作
44                         ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
45                     else { // 桶內元素是連結串列結構，利用高低位遷移
46                         Node<K,V> loHead = null, loTail = null;
47                         Node<K,V> hiHead = null, hiTail = null;
48                         Node<K,V> next;
49                         do {
50                             next = e.next;
51                             if ((e.hash & oldCap) == 0) {
52                                 if (loTail == null)
53                                     loHead = e;
54                                 else
55                                     loTail.next = e;
56                                 loTail = e;
57                             }
58                             else {
59                                 if (hiTail == null)
60                                     hiHead = e;
61                                 else
62                                     hiTail.next = e;
63                                 hiTail = e;
64                             }
65                         } while ((e = next) != null);
66                         if (loTail != null) {
67                             loTail.next = null;
68                             newTab[j] = loHead;
69                         }
70                         if (hiTail != null) {
71                             hiTail.next = null;
72                             newTab[j + oldCap] = hiHead;
73                         }
74                     }
75                 }
76             }
77         }
78         return newTab;
79     }

  • put--新增元素

　　jdk1.8之後是先插入元素，再判斷是否需要擴容。

 1     public V put(K key, V value) {
 2         return putVal(hash(key), key, value, false, true);
 3     }
 4 
 5     final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 6                    boolean evict) {
 7         Node<K,V>[] tab; Node<K,V> p; int n, i;
 8         if ((tab = table) == null || (n = tab.length) == 0)
 9             // 如果table為空，會先進行擴容
10             n = (tab = resize()).length;
11         if ((p = tab[i = (n - 1) & hash]) == null)  // 如果要插入的key對應索引為空，直接新建一個節點
12             tab[i] = newNode(hash, key, value, null);
13         else {  // 要插入的key對應索引不為空
14             Node<K,V> e; K k;
15             if (p.hash == hash &&
16                 ((k = p.key) == key || (key != null && key.equals(k)))) // 該索引位頭結點key與要插入key相等
17                 e = p;
18             else if (p instanceof TreeNode) // 該索引位頭結點與插入key不相等，並且桶內是紅黑樹結構，則進行紅黑樹方式插入
19                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
20             else {  // 該索引位頭結點與插入key不相等，並且桶內是連結串列結構
21                 for (int binCount = 0; ; ++binCount) {
22                     if ((e = p.next) == null) { // 頭結點下一個節點為空，說明沒有節點的key與要插入的key相等，直接新建一個節點
23                         p.next = newNode(hash, key, value, null);
24                         if (binCount >= TREEIFY_THRESHOLD - 1) // 連結串列長度大於8時，將連結串列轉為紅黑樹（-1是因為binCount是從0開始計數的）
25                             treeifyBin(tab, hash);  // 如果容量小於64，會進行擴容處理。大於等於64才會轉為紅黑樹
26                         break;
27                     }
28                     if (e.hash == hash &&
29                         ((k = e.key) == key || (key != null && key.equals(k))))
30                         break;
31                     p = e;
32                 }
33             }
34             if (e != null) { // e!=null，說明之前存在該key
35                 V oldValue = e.value;
36                 if (!onlyIfAbsent || oldValue == null)
37                     e.value = value;
38                 afterNodeAccess(e);
39                 return oldValue;
40             }
41         }
42         ++modCount;
43         // 如果之前不存在該key，會判斷元素數量是否達到閾值，如果達到閾值則進行擴容
44         if (++size > threshold)
45             resize();
46         afterNodeInsertion(evict);
47         return null;
48     }

  • remove--刪除元素

 1     public V remove(Object key) {
 2         Node<K,V> e;
 3         return (e = removeNode(hash(key), key, null, false, true)) == null ?
 4             null : e.value;
 5     }
 6 
 7     final Node<K,V> removeNode(int hash, Object key, Object value,
 8                                boolean matchValue, boolean movable) {
 9         Node<K,V>[] tab; Node<K,V> p; int n, index;
10         if ((tab = table) != null && (n = tab.length) > 0 &&
11             (p = tab[index = (n - 1) & hash]) != null) {    // 判斷陣列不為空，並且要刪除key對應的索引位元素不為空
12             Node<K,V> node = null, e; K k; V v;
13             if (p.hash == hash &&
14                 ((k = p.key) == key || (key != null && key.equals(k)))) // 該索引位頭結點key與要刪除的key相等
15                 node = p;
16             else if ((e = p.next) != null) {    // 該索引位頭結點與插入key不相等
17                 // 首先根據key獲取節點
18                 if (p instanceof TreeNode)  
19                     node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
20                 else {
21                     do {
22                         if (e.hash == hash &&
23                             ((k = e.key) == key ||
24                              (key != null && key.equals(k)))) {
25                             node = e;
26                             break;
27                         }
28                         p = e;
29                     } while ((e = e.next) != null);
30                 }
31             }
32             // 如果獲取到的節點不為空，並且與傳入的值相等，進行刪除操作
33             if (node != null && (!matchValue || (v = node.value) == value ||
34                                  (value != null && value.equals(v)))) {
35                 if (node instanceof TreeNode)
36                     ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
37                 else if (node == p)
38                     tab[index] = node.next;
39                 else
40                     p.next = node.next;
41                 ++modCount;
42                 --size;
43                 afterNodeRemoval(node);
44                 return node;
45             }
46         }
47         return null;
48     }

  • treeifyBin--連結串列樹化，首先會判斷容量大小是否達到64，如果小於會進行擴容處理

 1     final void treeifyBin(Node<K,V>[] tab, int hash) {
 2         int n, index; Node<K,V> e;
 3         if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
 4             resize();
 5         else if ((e = tab[index = (n - 1) & hash]) != null) {
 6             TreeNode<K,V> hd = null, tl = null;
 7             do {
 8                 TreeNode<K,V> p = replacementTreeNode(e, null);
 9                 if (tl == null)
10                     hd = p;
11                 else {
12                     p.prev = tl;
13                     tl.next = p;
14                 }
15                 tl = p;
16             } while ((e = e.next) != null);
17             if ((tab[index] = hd) != null)
18                 hd.treeify(tab);
19         }
20     }

  • split--負責完成舊陣列紅黑樹結構遷移到新陣列中的工作（靜態內部類TreeNode內部方法）

 1     final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
 2         TreeNode<K,V> b = this;
 3         // Relink into lo and hi lists, preserving order
 4         TreeNode<K,V> loHead = null, loTail = null;
 5         TreeNode<K,V> hiHead = null, hiTail = null;
 6         int lc = 0, hc = 0;
 7         for (TreeNode<K,V> e = b, next; e != null; e = next) {
 8             next = (TreeNode<K,V>)e.next;
 9             e.next = null;
10             if ((e.hash & bit) == 0) {  // 區分數連結串列的高低位。為0說明是低位
11                 if ((e.prev = loTail) == null)  // 如果低位尾部節點為空，說明此時低位連結串列為空，e為低位連結串列第一個節點
12                     loHead = e;
13                 else    // 如果低位尾部節點不為空，說明此時低位連結串列不為空，此時e不為第一個。將之前的低位尾部節點下一個節點指向當前處理的節點e
14                     loTail.next = e;
15                 loTail = e; // 此時處理的節點e為低位的尾部節點
16                 ++lc;
17             }
18             else {  // 此時e為高位
19                 if ((e.prev = hiTail) == null)  // 如果高位尾部節點為空，說明此時高位連結串列為空，e為高位連結串列第一個節點
20                     hiHead = e;
21                 else    // 如果高位尾部節點不為空，說明此時高位連結串列不為空，此時e不為第一個。將之前的高位尾部節點下一個節點指向當前處理的節點e
22                     hiTail.next = e;
23                 hiTail = e; // 此時處理的節點e為高位的尾部節點
24                 ++hc;
25             }
26         }
27     
28         if (loHead != null) {
29             if (lc <= UNTREEIFY_THRESHOLD)
30                 // 如果計算的低位節點數量<=6，取消樹狀結構化，返回的是Node
31                 tab[index] = loHead.untreeify(map);
32             else {
33                 tab[index] = loHead;
34                 if (hiHead != null) // 如果hiHead==null，說明只有一個樹，樹結構不變
35                     loHead.treeify(tab);
36             }
37         }
38         if (hiHead != null) {
39             if (hc <= UNTREEIFY_THRESHOLD)
40                 // 如果計算的高位節點數量<=6，取消樹狀結構化，返回的是Node
41                 tab[index + bit] = hiHead.untreeify(map);
42             else {
43                 tab[index + bit] = hiHead;
44                 if (loHead != null) // 如果loHead==null，說明只有一個樹，樹結構不變
45                     hiHead.treeify(tab);
46             }
47         }
48     }

  • treeify--連結串列樹化（靜態內部類TreeNode內部方法）

 1     final void treeify(Node<K,V>[] tab) {
 2         TreeNode<K,V> root = null;
 3         for (TreeNode<K,V> x = this, next; x != null; x = next) {
 4             next = (TreeNode<K,V>)x.next;
 5             x.left = x.right = null;
 6             if (root == null) {
 7                 x.parent = null;
 8                 x.red = false;  // 根節點顏色為黑色
 9                 root = x;
10             }
11             else {
12                 // x:當前要處理的節點
13                 K k = x.key;
14                 int h = x.hash;
15                 Class<?> kc = null;
16                 // 從根節點遍歷紅黑樹
17                 for (TreeNode<K,V> p = root;;) {
18                     int dir, ph;
19                     // p:遍歷到的紅黑樹節點
20                     K pk = p.key;
21                     // 確定要插入的節點是樹的左節點還是右節點
22                     if ((ph = p.hash) > h)
23                         dir = -1;
24                     else if (ph < h)
25                         dir = 1;
26                     else if ((kc == null &&
27                               (kc = comparableClassFor(k)) == null) ||
28                              (dir = compareComparables(kc, k, pk)) == 0)
29                         dir = tieBreakOrder(k, pk);
30 
31                     TreeNode<K,V> xp = p;
32                     if ((p = (dir <= 0) ? p.left : p.right) == null) {
33                         // 表示x節點找到了要插入的地方
34                         x.parent = xp;
35                         if (dir <= 0)   // x插入在p節點的左邊
36                             xp.left = x;
37                         else
38                             xp.right = x;   // x插入在p節點的右邊
39                         root = balanceInsertion(root, x);
40                         break;
41                     }
42                 }
43             }
44         }
45         moveRootToFront(tab, root);
46     }

  • untreeify--取消樹化（靜態內部類TreeNode內部方法）　

 1     final Node<K,V> untreeify(HashMap<K,V> map) {
 2         Node<K,V> hd = null, tl = null;
 3         for (Node<K,V> q = this; q != null; q = q.next) {
 4             Node<K,V> p = map.replacementNode(q, null);
 5             if (tl == null)
 6                 // 如果尾部節點為空，說明當前節點是第一個處理的節點（頭結點）
 7                 hd = p;
 8             else
 9                 tl.next = p;    // 如果尾部節點不為空，將之前尾部節點的下一個節點指向當前節點
10             tl = p; // 將當前節點設定為尾部節點
11         }
12         return hd;
13     }

附錄

HashMap原始碼詳細註釋Github地址：https://github.com/y2ex/jdk-source/blob/jdk1.8.0_271/src/main/java/java/util/HashMap.java

jdk1.8原始碼Github地址：https://github.com/y2ex/jdk-source/tree/jdk1.8.0_271

相關文章