帶你逐行分析 HashMap 源碼
一、寫在前面
相信讀者也看過了不少講解 HashMap 源碼的文章了，筆者認爲，一切脫離源碼去講原理的都是泛泛而談。一些所謂的原理大都是閱讀源碼之後的個人概括，這些概括參差不齊，再加上沒有閱讀源碼，讀者們是很難有切身體會的。正因如此，筆者逐行分析了 HashMap 的源碼後，開啓了本場 Chat。
筆者在閱讀 HashMap 源碼的時候，曾對每個內部屬性，每個內部方法和方法調用邏輯做了簡要註釋，但在整理成文的時候，還是遇到了略微的困難。對於一些內部屬性的解釋，需要結合它在一些方法的使用中發揮的作用來綜合說明，筆者打算按照從淺到深的順序，先帶讀者熟悉 HashMap 的宏觀設計思想，再通讀一遍源碼，然後講解源碼的設計細節。要讓讀者邊看文字邊對照源碼進行學習，形成自己的領悟和體會，避免造成筆者一人的泛泛而談。
無論自己的領悟是深是淺，終歸是自己的，無論別人的領悟多麼高深，那也是別人的。希望每個讀者都能有自己的收穫和體會。
Java 版本
$ java -version
java version "1.8.0\_211"
Java(TM) SE Runtime Environment (build 1.8.0\_211-b12) Java HotSpot(TM) 64-Bit Server VM (build 25.211-b12, mixed mode)
二、HashMap官方說明
以下內容主要對 HashMap 的一些特性和注意事項做了簡單的說明，筆者對一些比較重要的知識點做了加粗處理。
基於哈希表的 Map 接口的實現。此實現提供所有可選的映射操作，並允許使用 null 值和 null 鍵。（除了不同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）此類不保證映射的順序，特別是它不保證該順序恆久不變。
此實現假定哈希函數將元素正確分佈在各桶之間，可爲基本操作（get 和 put）提供穩定的性能。迭代集合視圖所需的時間與 HashMap 實例的“容量”（桶的數量）及其大小（鍵-值映射關係數）的和成比例。所以，如果迭代性能很重要，則不要將初始容量設置得太高（或將加載因子設置得太低）。
HashMap 的實例有兩個參數影響其性能：初始容量 和加載因子。容量 是哈希表中桶的數量，初始容量只是哈希表在創建時的容量。加載因子 是哈希表在其容量自動增加之前可以達到多滿的一種尺度。當哈希表中的條目數超出了加載因子與當前容量的乘積時，通過調用 rehash 方法將容量翻倍。
通常，默認加載因子（.75）在時間和空間成本上尋求一種折衷。加載因子過高雖然減少了空間開銷，但同時也增加了查詢成本（在大多數 HashMap 類的操作中，包括 get 和 put 操作，都反映了這一點）。在設置初始容量時應該考慮到映射中所需的條目數及其加載因子，以便最大限度地降低 rehash 操作次數。如果初始容量大於最大條目數除以加載因子，則不會發生 rehash 操作。
如果很多映射關係要存儲在 HashMap 實例中，則相對於按需執行自動的 rehash 操作以增大表的容量來說，使用足夠大的初始容量創建它將使得映射關係能更有效地存儲。
注意，此實現不是同步的。如果多個線程同時訪問此映射，而其中至少一個線程從結構上修改了該映射，則它必須保持外部同步。（結構上的修改是指添加或刪除一個或多個映射關係的操作；僅改變與實例已經包含的鍵關聯的值不是結構上的修改。）這一般通過對自然封裝該映射的對象進行同步操作來完成。如果不存在這樣的對象，則應該使用 Collections.synchronizedMap 方法來“包裝”該映射。最好在創建時完成這一操作，以防止對映射進行意外的不同步訪問，如下所示：
Map m = Collections.synchronizedMap(new HashMap(...));
由所有此類的“集合視圖方法”所返回的迭代器都是快速失敗 的：在迭代器創建之後，如果從結構上對映射進行修改，除非通過迭代器自身的 remove 或 add 方法，其他任何時間任何方式的修改，迭代器都將拋出 ConcurrentModificationException。因此，面對併發的修改，迭代器很快就會完全失敗，而不冒在將來不確定的時間任意發生不確定行爲的風險。
注意，迭代器的快速失敗行爲不能得到保證，一般來說，存在不同步的併發修改時，不可能作出任何堅決的保證。快速失敗迭代器盡最大努力拋出 ConcurrentModificationException。因此，編寫依賴於此異常程序的方式是錯誤的，正確做法是：迭代器的快速失敗行爲應該僅用於檢測程序錯誤。
此類是 Java Collections Framework 的成員。
三、HashMap存儲結構
學習源碼之前，最好在腦海中明確 HashMap 的存儲結構，不然後面閱讀源碼，遇到容量、數量等參數可能會有些許困惑。
相信你已經有所耳聞，HashMap 內部包含了一個 Node 類型的數組 table。Node 存儲着鍵值對。
Node 類源碼如下：
static class Node\<K, V\> implements Map.Entry\<K, V\> {
final int 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;
}
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;
}
}
它包含了四個字段，從 next 字段我們可以看出 Node 是一個鏈表。即數組中的每個位置被當成一個桶，一個桶存放一個鏈表。HashMap 使用鏈地址法來解決哈希衝突，即同一個鏈表中存放哈希值和散列桶取模運算結果相同的 Node。HashMap 存儲結構如下圖所示：
四、HashMap 靜態屬性
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
默認的 table 容量，1<<4 = 2^4 = 16，規定必須是 2 的冪。
static final int MAXIMUM_CAPACITY = 1 << 30;
最大的 table 容量，規定必須是 2 的冪，類型爲 int，掐指一算，那隻能是 0100 0000 0000 0000 0000 0000 0000 0000。因爲 Java中 int 有 32 位，除第 1 位符號位外，數值部分只有 31 位，只有 1<<30 滿足條件。
這裏需要說明一下，對於 2 的冪，在計算機的世界裏是一羣特殊的存在，它們的二進制中只有一個1，其餘位全爲 0。這個特性會影響與它進行位運算後的結果具有一些特殊效果。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
構造函數中未指定時使用的負載因子。
static final int TREEIFY_THRESHOLD = 8;
相信很多人知道鏈表長度大於 8 會轉爲紅黑樹，依據也就是這個字段的註釋說明。但其實這只是條件之一，另一個條件就是下面這個參數。
static final int MIN_TREEIFY_CAPACITY = 64;
在進行鏈表轉紅黑樹的時候，第一步是檢查鏈表的長度是否大於等於 8，第二步會檢查 table 數組的容量是否小於此數值，若小於，則取消轉爲紅黑樹，只對 table 數組進行擴容。
static final int UNTREEIFY_THRESHOLD = 6;
當鍵值對數量過多時需要對 table 數組進行擴容，並且將每個鍵值對放到新的桶中（或者不變）。原來的桶的內部結構有可能是鏈表，也有可能是紅黑樹，經過一番洗牌之後，如果桶結構爲紅黑樹的鍵值對數量過低，就會重新轉變爲鏈表。低到哪個程度呢？就是這個字段對應的大小。
五、HashMap 成員屬性
transient Node<K,V>[] table;
HashMap 的內部 Node 類型的數組，屬性名爲 table。
transient int modCount;
該字段起標記作用，值是對該 HashMap 進行結構修改的次數，主要用於迭代器訪問時檢測 HashMap 是否因爲刪除等其它操作內部機構發生變化。
transient Set<Map.Entry<K,V>> entrySet;
HashMap 內部有很多內部類，擴展了 HashMap 的一些功能，EntrySet 類就是其中一種，該類較爲簡單，無內部屬性，你可以理解爲一個工具類，對 HashMap 進行了簡單的封裝，提供了方便的遍歷、刪除等操作。
調用 HashMap 的 entrySet() 方法就可以返回 EntrySet 實例對象，爲了不至於每次調用該方法都返回新的 EntrySet 對象，所以設置該屬性，緩存 EntrySet 實例。
transient int size;
鍵值對的數量。
int threshold;
size 的臨界值，當 size 大於 threshold 就必須進行擴容操作。
final float loadFactor;
負載因子，被 final 修飾，在構造方法中就被初始化，不指定就用默認的。
六、HashMap 構造方法
HashMap 的共有三個構造方法，源碼如下：
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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);
}
初看源碼，可以發現，被 final 修飾的 loadFactor 一定會在構造方法中被初始化。
帶參構造方法主要做的就是對 initialCapacity 和 loadFactor 的校驗工作，並且會通過 tableSizeFor 方法計算其合理的初始容量，由於此時 table 數組尚未實例化，所以該合理的初始容量被暫存在 threshold 屬性中，由其代爲保管。
七、tableSizeFor(int cap) 方法
tableSizeFor(int cap) 靜態方法的作用是計算其合理的初始容量，也就是滿足 2 的冪，且大於等於參數 cap，最接近的那一個數即可。該方法使用位運算設計了高效的算法邏輯，方法源碼如下：
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
參數 cap 的值肯定大於 0，故 n 大於等於 0 ，假設 n = 0，經過右移之後，依舊爲 0 ，0 與 0 異或依舊爲 0 ，通過 return 語句的 n+ 1 計算得 1，即 2 的 0 次冪。
當 n 大於 0 時，n 的二進制位肯定會有位的值爲 1，即 001xx…xx 的形式，接着，對 n 右移 1 位得 0001xx…xx，再進行位或，由於 1 與 0 或 1 異或結果都爲 1，所以結果必爲 0011xx…xx 的形式。以此類推，位移 2 位、4 位、8 位、 16 位，最終該算法能讓最高位的 1 後面的所有位全變爲 1。
下面用一張圖舉例說明一下：
八、hash(Object key) 方法
該方法是 HashMap 的核心靜態方法，用於計算 key 的 hash 值，該方法的源碼如下：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
方法邏輯很簡單，key 爲 null 返回 0，根據桶下標計算公式 (capacity - 1) & hash，以及 0 與 0 或 1 位與結果均爲 0，可知，null 鍵對應的桶下標爲 0 。
當 key 不爲 null 時，調用 key.hashCode() 並將 hashCode 的低 16 位與高 16 位異或。
這步操作是因爲 table 數組使用 2 的冪作爲容量，且計算桶下標是通過 (capacity - 1) & hash，所以僅在當前容量上方的位中變化的 hashCode 將始終發生衝突。
舉個例子，初始容量爲 16，hash 值按 32 位計算：
16 = 10000（二進制）
16 - 1 = 0000 0000 0000 0000 0000 0000 0000 1111
hash1 = 0000 0000 0000 0000 0000 0000 0001 1111
hash2 = 0000 0000 0000 0000 0000 0000 0011 1111
因爲 0 與任何數位與 & 的結果都是 0 ，所以無論 hash 值是多少，計算後除後 4 位外的位必定都爲 0，如果 hash 值只在前 32 - 4 = 28 位發生變化，計算後的結果都是相同的，都會放入同一個桶中，始終發生衝突。
因此，設計者們在速度，實用性和位擴展質量之間進行權衡後應用了一種變換，通過將 hashcode 的低 16 位與高 16 位異或向下傳播較高位的影響。
由於許多常見的哈希值已經合理分佈（比如 hash 值的前 16 位都爲 0 的一些數，它們的低 16 位與 高 16 位異或後值不變，因此無法從擴展中受益），並且由於我們使用樹來處理容器中的大量衝突，因此我們僅以最方便的方式對一些移位後的位進行異或，以減少系統損失，以及合併最高位的影響，否則由於 table 數組容量的限制，這些位將永遠不會在索引計算中使用。
九、桶下標計算公式
計算桶下標時，需要先通過 HashMap 內部的 hash() 方法計算其 hash 值，然後將 hash 值對桶個數取模，即：
hash % capacity
如果能保證 capacity 爲 2 的冪，那麼就可以將這個操作轉換爲高效的位運算，也就是 HashMap 源碼中的桶下標計算公式：
(capacity - 1) & hash
以上便是 HashMap 內部數組的容量爲 2 的冪的其中一個原因，另一個原因是在 resize() 擴容方法中可以更高效的重新計算桶下標。
十、put(K key, V value) 方法
該方法將指定值與該映射中的指定鍵相關聯。若是 Key 已存在，則覆蓋並返回舊的 Value（可爲 null）；若是沒有鍵值對映射，則返回 null。該方法源碼如下：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
可以看到，該方法實際是封裝的 putVal() 方法。putVal() 方法有 5 個參數，依次爲 key 的 hash 值，key 本身，value 本身，參數 onlyIfAbsent 表示是否在鍵已存在的情況放棄覆蓋舊值，參數 evict 作爲 afterNodeInsertion(evict) 方法的參數，並不爲 HashMap 所用，而是交由 LinkedHashMap 處理。
該方法的源碼如下：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 步驟①：table爲空則創建
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 步驟②：計算桶下標，若是沒有碰撞直接放桶裏
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// 步驟③：發生hash碰撞，若鍵已存在就返回該Node，並用屬性 e 引用，若鍵不存在就創建一個新的Node，並直接插入到桶中
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);
// 鏈表長度大於8轉爲紅黑樹處理
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;
}
}
// 步驟④：該鍵已經存在
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();
afterNodeInsertion(evict);
return null;
}
十一、resize() 方法
該方法的作用是初始化 table 數組，或增加 table 數組的大小。
如果 table 數組爲 null，則根據字段 threshold 中保持的初始容量進行分配。否則擴容，因爲我們使用的是 2 的冪，所以每個桶中的元素必須保持相同的索引，或者在新 table 中以 2 的冪偏移。
舉個例子，例如容量從 16 擴展爲 32 時，具體變化如下：
16-1 = 0000 0000 0000 0000 0000 0000 0000 1111
hash1 = 0000 0000 0000 0000 0000 0000 0000 1111
hash2 = 0000 0000 0000 0000 0000 0000 0001 1111
// 桶下標爲
(16-1)&hash1 = 0000 0000 0000 0000 0000 0000 0000 1111
(16-1)&hash2 = 0000 0000 0000 0000 0000 0000 0000 1111
容量爲 16 時，hash1 和 hash2 經過桶下標計算後結果相同，會進入同一個桶中。當容量擴展爲 32 後，新的桶下標計算過程如下所示：
32-1 = 0000 0000 0000 0000 0000 0000 0001 1111
hash1 = 0000 0000 0000 0000 0000 0000 0000 1111
hash2 = 0000 0000 0000 0000 0000 0000 0001 1111
// 桶下標爲
(32-1)&hash1 = 0000 0000 0000 0000 0000 0000 0000 1111
(32-1)&hash2 = 0000 0000 0000 0000 0000 0000 0001 1111
hash1 和 hash2 經過桶下標公式重新計算之後，hash1的結果不變，所以依舊在原來的桶裏；而 hash2 的結果比原來多了 1 位，即 2^4 = 16，也就是偏移了原來的容量大小。如下圖所示：
因此，在擴充 HashMap 的時候，不需要重新計算 hash，只需要檢查二進制 hash 中與二進制桶下標中新增的有效位的位置相同的那個位（以下簡稱“新增位”）是 0 還是 1 即可，是 0 的話索引沒變，是 1 iased;box-sizing:border-box;padding:2px 4px;color:rgb(63, 63, 63);background-color:rgba(128, 128, 128, 0.075);border-radius:4px;white-space:normal;font-family:“Source Code Pro”, monospace;font-size:0.9em;outline:0px;">hash & oldCap 位與運算檢查該新增位。oldCap 是 2 的冪，故二進制表示只有 1 位是 1，且該位正好與之對應。不得不說這個設計還是非常巧妙的，既省去了重新計算 hash 值的時間，而且，由於新增的 1 位是 0 還是 1 可以認爲是隨機的，因此在擴容的過程，均勻的把之前碰撞的節點分散到新舊桶中。
resize() 方法的源碼如下：
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// 步驟①：根據 oldCap 判斷是擴容還是初始化數組，若是擴容..
if (oldCap > 0) {
// 超過最大容量就不再擴容，隨它去碰撞
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 沒超過最大值，就擴容爲原來的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 步驟②：若是初始化數組，若是字段 threshold 中已經保存初始容量
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 步驟③：若是初始化數組，若是字段 threshold 中沒有保存初始容量，則使用默認容量
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"})
// 步驟⑤：實例化新的 table 數組
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// 步驟⑥：將每個桶及內部節點都移到新的 table 數組中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
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 { // preserve order
// 原桶的頭尾節點引用
Node<K,V> loHead = null, loTail = null;
// 新桶的頭尾節點引用
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
// 循環遍歷桶內碰撞節點
do {
next = e.next;
// 新增位是 0 放原桶
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 新增位是 1 放新桶
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 原桶放新 table 數組
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 新桶放新 table 數組
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
十二、get(Object key) 方法
該方法返回指定鍵所映射到的值，如果不包含該鍵對應的映射關係，則返回 null。
返回值爲 null 不一定表示不包含該鍵對應的映射關係，也可能表示該鍵對應的值爲 null。 如果需要驗證是否存在該鍵對應的映射關係可以調用 containsKey() 方法。
該方法的源碼如下：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
方法內部調用的 getNode() 方法，參數爲 key 的 hash 值與 key 本身，方法的源碼如下：
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) {
// 步驟②：每次 get 都要先檢查該桶頭節點是否是要找的鍵值對，因爲不存在哈希碰撞的可能性較大
if (first.hash == hash && // always check first node
((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;
}
十三、treeifyBin(Node[] tab, int hash) 方法
在前面對 put 操作的介紹中，當鏈表的長度大於等於 TREEIFY_THRESHOLD 也就是 8 時，會調用 treeifyBin() 方法將桶的結構由 Node 轉爲 TreeNode，即鏈表轉化爲紅黑樹。但嚴格來說，這句話不應該如此表述。因爲 treeifyBin() 方法會判斷當前 table 數組的容量是否小於 MIN_TREEIFY_CAPACITY（64），若是，則放棄鏈表轉爲紅黑樹，而選擇擴容。
該方法的源碼如下：
final void treeifyBin(Node\<K,V\>[] tab, int hash) {
int n, index; Node<K,V> e;
// 如果當前 table 數組的容量小於 64 就放棄樹化，選擇擴容。
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
// 鏈表轉爲紅黑樹
else if ((e = tab[index = (n - 1) & hash]) != null) {
// hd：鏈表頭節點，tl：鏈表尾節點
TreeNode<K,V> hd = null, tl = null;
do {
// 將Node轉爲TreeNode，並保持鏈表的結構
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
// 這一步纔是真正的鏈表轉爲紅黑樹
hd.treeify(tab);
}
}
十四、TreeNode.treeify(Node[] tab) 方法
HashMap 的桶類型除了 Node（鏈表）外，還有 TreeNode（樹）。TreeNode 類包含成員方法 treeify()，該方法的作用是形成以當前 TreeNode 對象爲根節點的紅黑樹。該方法源碼如下：
final void treeify(Node\<K,V\>[] tab) {
TreeNode<K,V> root = null;
// 步驟①：遍歷當前TreeNode鏈表
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
// 步驟②：如果還未設置根節點..
if (root == null) {
x.parent = null;
x.red = false;
root = x;
}
// 步驟③：如果已設置根節點..
else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;
// 步驟④：從根節點開始遍歷，插入新節點
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
// 步驟⑤：比較當前節點的hash值與新節點的hash值
// 若是新節點hash值較小
if ((ph = p.hash) > h)
dir = -1;
// 若是新節點的hash值較大
else if (ph < h)
dir = 1;
// 若是新節點與當前節點的hash值相等
else if (
// 如果新節點的key沒有實現Comparable接口..
(kc == null && (kc = comparableClassFor(k)) == null)
// 或者實現了Comparable接口但是k.compareTo(pk)結果爲0
||(dir = compareComparables(kc, k, pk)) == 0)
// 則調用tieBreakOrder繼續比較大小
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
// 步驟⑥：如果新節點經比較後小於等於當前節點且當前節點的左子節點爲null，則插入新節點，反之亦然
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
// 步驟⑦：平衡紅黑樹
root = balanceInsertion(root, x);
break;
}
}
}
}
// 步驟⑧：確保給定的根節點是所在桶的第一個節點
moveRootToFront(tab, root);
}
歡迎關注我的公衆號，回覆關鍵字“大禮包” ，將會有大禮相送！！！ 祝各位面試成功！！！
