作者：小傅哥
博客：https://bugstack.cn
沉淀、分享、成長，讓自己和他人都能有所收獲！😄
一、前言
在上一章節我們講解並用數據驗證了，HashMap中的，散列表的實現、擾動函數、負載因子以及擴容拆分等核心知識點以及相應的作用。
除了以上這些知識點外，HashMap還有基本的數據功能；存儲、刪除、獲取、遍歷，在這些功能中經常會聽到鏈表、紅黑樹、之間轉換等功能。而紅黑樹是在jdk1.8引入到HashMap中解決鏈表過長問題的，簡單說當鏈表長度>=8時，將鏈表轉換位紅黑樹(當然這里還有一個擴容的知識點，不一定都會樹化[MIN_TREEIFY_CAPACITY])。
那么本章節會進行講解以下知識點；
- 數據插入流程和源碼分析
- 鏈表樹化以及樹轉鏈表
- 遍歷過程中的無序Set的核心知識
🕵注意： 建議閱讀上一篇后，再閱讀本篇文章《HashMap核心知識，擾動函數、負載因子、擴容鏈表拆分，深度學習》
二、HashMap源碼分析
1. 插入
1.1 疑問點&考題
通過上一章節的學習：《HashMap核心知識，擾動函數、負載因子、擴容鏈表拆分，深度學習》
大家對於一個散列表數據結構的HashMap往里面插入數據時，基本已經有了一個印象。簡單來說就是通過你的Key值取得哈希再計算下標，之后把相應的數據存放到里面。
但再這個過程中會遇到一些問題，比如；
- 如果出現哈希值計算的下標碰撞了怎么辦？
- 如果碰撞了是擴容數組還是把值存成鏈表結構，讓一個節點有多個值存放呢？
- 如果存放的數據的鏈表過長，就失去了散列表的性能了，怎么辦呢？
- 如果想解決鏈表過長，什么時候使用樹結構呢，使用哪種樹呢？
這些疑問點都會在后面的內容中逐步講解，也可以自己思考一下，如果是你來設計，你會怎么做。
1.2 插入流程和源碼分析
HashMap插入數據流程圖
visio原版流程圖，可以通過關注公眾號：bugstack蟲洞棧，進行下載
以上就是HashMap中一個數據插入的整體流程，包括了；計算下標、何時擴容、何時鏈表轉紅黑樹等，具體如下；
-
首先進行哈希值的擾動，獲取一個新的哈希值。
(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); -
判斷tab是否位空或者長度為0，如果是則進行擴容操作。
if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; -
根據哈希值計算下標，如果對應小標正好沒有存放數據，則直接插入即可否則需要覆蓋。
tab[i = (n - 1) & hash]) -
判斷tab[i]是否為樹節點，否則向鏈表中插入數據，是則向樹中插入節點。
-
如果鏈表中插入節點的時候，鏈表長度大於等於8，則需要把鏈表轉換為紅黑樹。
treeifyBin(tab, hash); -
最后所有元素處理完成后，判斷是否超過閾值；
threshold，超過則擴容。 -
treeifyBin,是一個鏈表轉樹的方法，但不是所有的鏈表長度為8后都會轉成樹，還需要判斷存放key值的數組桶長度是否小於64MIN_TREEIFY_CAPACITY。如果小於則需要擴容，擴容后鏈表上的數據會被拆分散列的相應的桶節點上，也就把鏈表長度縮短了。
JDK1.8 HashMap的put方法源碼如下:
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
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，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 {
Node<K,V> e; K k;
// 如果鍵的值以及節點 hash 等於鏈表中的第一個鍵值對節點時，則將 e 指向該鍵值對
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果桶中的引用類型為 TreeNode，則調用紅黑樹的插入方法
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;
}
// 條件為 true，表示當前鏈表包含要插入的鍵值對，終止遍歷
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 判斷要插入的鍵值對是否存在 HashMap 中
if (e != null) { // existing mapping for key
V oldValue = e.value;
// onlyIfAbsent 表示是否僅在 oldValue 為 null 的情況下更新鍵值對的值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 鍵值對數量超過閾值時，則進行擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
1.3 擴容機制
HashMap是基於數組+鏈表和紅黑樹實現的，但用於存放key值得的數組桶的長度是固定的，由初始化決定。
那么，隨着數據的插入數量增加以及負載因子的作用下，就需要擴容來存放更多的數據。而擴容中有一個非常重要的點，就是jdk1.8中的優化操作，可以不需要再重新計算每一個元素的哈希值，這在上一章節中已經講到，可以閱讀系列專題文章，機制如下圖；
里我們主要看下擴容的代碼(注釋部分)；
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// Cap 是 capacity 的縮寫，容量。如果容量不為空，則說明已經初始化。
if (oldCap > 0) {
// 如果容量達到最大1 << 30則不再擴容
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
}
else if (oldThr > 0) // initial capacity was placed in threshold
// initial capacity was placed in threshold 翻譯過來的意思，如下；
// 初始化時，將 threshold 的值賦值給 newCap，
// HashMap 使用 threshold 變量暫時保存 initialCapacity 參數的值
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 這一部分也是，源代碼中也有相應的英文注釋
// 調用無參構造方法時，數組桶數組容量為默認容量 1 << 4; aka 16
// 閥值；是默認容量與負載因子的乘積，0.75
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// newThr為0，則使用閥值公式計算容量
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"})
// 初始化數組桶，用於存放key
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// 如果舊數組桶，oldCap有值，則遍歷將鍵值映射到新數組桶中
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)
// 這里split，是紅黑樹拆分操作。在重新映射時操作的。
((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;
// 這里是鏈表，如果當前是按照鏈表存放的，則將鏈表節點按原順序進行分組{這里有專門的文章介紹，如何不需要重新計算哈希值進行拆分《HashMap核心知識，擾動函數、負載因子、擴容鏈表拆分，深度學習》}
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;
}
以上的代碼稍微有些長，但是整體的邏輯還是蠻清晰的，主要包括；
- 擴容時計算出新的newCap、newThr，這是兩個單詞的縮寫，一個是Capacity ，另一個是閥Threshold
- newCap用於創新的數組桶
new Node[newCap]; - 隨着擴容后，原來那些因為哈希碰撞，存放成鏈表和紅黑樹的元素，都需要進行拆分存放到新的位置中。
1.4 鏈表樹化
HashMap這種散列表的數據結構，最大的性能在於可以O(1)時間復雜度定位到元素，但因為哈希碰撞不得已在一個下標里存放多組數據，那么jdk1.8之前的設計只是采用鏈表的方式進行存放，如果需要從鏈表中定位到數據時間復雜度就是O(n)，鏈表越長性能越差。因為在jdk1.8中把過長的鏈表也就是8個，優化為自平衡的紅黑樹結構，以此讓定位元素的時間復雜度優化近似於O(logn)，這樣來提升元素查找的效率。但也不是完全拋棄鏈表，因為在元素相對不多的情況下，鏈表的插入速度更快，所以綜合考慮下設定閾值為8才進行紅黑樹轉換操作。
鏈表轉紅黑樹，如下圖；
以上就是一組鏈表轉換為紅黑樹的情況，元素包括；40、51、62、73、84、95、150、161 這些是經過實際驗證可分配到Idx：12的節點
通過這張圖，基本可以有一個鏈表換行到紅黑樹的印象，接下來閱讀下對應的源碼。
鏈表樹化源碼
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 這塊就是我們上面提到的，不一定樹化還可能只是擴容。主要桶數組容量是否小於64 MIN_TREEIFY_CAPACITY
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
// 又是單詞縮寫；hd = head (頭部)，tl = tile (結尾)
TreeNode<K,V> hd = null, tl = null;
do {
// 將普通節點轉換為樹節點，但此時還不是紅黑樹，也就是說還不一定平衡
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);
}
}
這一部分鏈表樹化的操作並不復雜，復雜點在於下一層的紅黑樹轉換上，這部分知識點會在后續章節中專門介紹；
以上源碼主要包括的知識點如下；
- 鏈表樹化的條件有兩點；鏈表長度大於等於8、桶容量大於64，否則只是擴容，不會樹化。
- 鏈表樹化的過程中是先由鏈表轉換為樹節點，此時的樹可能不是一顆平衡樹。同時在樹轉換過程中會記錄鏈表的順序，
tl.next = p，這主要方便后續樹轉鏈表和拆分更方便。 - 鏈表轉換成樹完成后，在進行紅黑樹的轉換。先簡單介紹下，紅黑樹的轉換需要染色和旋轉，以及比對大小。在比較元素的大小中，有一個比較有意思的方法，
tieBreakOrder加時賽，這主要是因為HashMap沒有像TreeMap那樣本身就有Comparator的實現。
1.5 紅黑樹轉鏈
在鏈表轉紅黑樹中我們重點介紹了一句，在轉換樹的過程中，記錄了原有鏈表的順序。
那么，這就簡單了，紅黑樹轉鏈表時候，直接把TreeNode轉換為Node即可，源碼如下；
final Node<K,V> untreeify(HashMap<K,V> map) {
Node<K,V> hd = null, tl = null;
// 遍歷TreeNode
for (Node<K,V> q = this; q != null; q = q.next) {
// TreeNode替換Node
Node<K,V> p = map.replacementNode(q, null);
if (tl == null)
hd = p;
else
tl.next = p;
tl = p;
}
return hd;
}
// 替換方法
Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
return new Node<>(p.hash, p.key, p.value, next);
}
因為記錄了鏈表關系，所以替換過程很容易。所以好的數據結構可以讓操作變得更加容易。
2. 查找
上圖就是HashMap查找的一個流程圖，還是比較簡單的，同時也是高效的。
接下來我們在結合代碼，來分析這段流程，如下；
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 &&
// 計算下標，哈希值與數組長度-1
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
// TreeNode 節點直接調用紅黑樹的查找方法，時間復雜度O(logn)
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;
}
以上查找的代碼還是比較簡單的，主要包括以下知識點；
- 擾動函數的使用，獲取新的哈希值，這在上一章節已經講過
- 下標的計算，同樣也介紹過
tab[(n - 1) & hash]) - 確定了桶數組下標位置，接下來就是對紅黑樹和鏈表進行查找和遍歷操作了
3. 刪除
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
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;
// 定位桶數組中的下標位置，index = (n - 1) & 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 指向該節點
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)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
- 刪除的操作也比較簡單，這里面都沒有太多的復雜的邏輯。
- 另外紅黑樹的操作因為被包裝了，只看使用上也是很容易。
4. 遍歷
4.1 問題點
HashMap中的遍歷也是非常常用的API方法，包括；
KeySet
for (String key : map.keySet()) {
System.out.print(key + " ");
}
EntrySet
for (HashMap.Entry entry : map.entrySet()) {
System.out.print(entry + " ");
}
從方法上以及日常使用都知道，KeySet是遍歷是無序的，但每次使用不同方式遍歷包括keys.iterator()，它們遍歷的結果是固定的。
那么從實現的角度來看，這些種遍歷都是從散列表中的鏈表和紅黑樹獲取集合值，那么他們有一個什么固定的規律嗎？
4.2 用代碼測試
測試的場景和前提；
- 這里我們要設定一個既有紅黑樹又有鏈表結構的數據場景
- 為了可以有這樣的數據結構，我們最好把HashMap的初始長度設定為64，避免在鏈表超過8位后擴容，而是直接讓其轉換為紅黑樹。
- 找到18個元素，分別放在不同節點(這些數據通過程序計算得來)；
- 桶數組02節點：24、46、68
- 桶數組07節點：29
- 桶數組12節點：150、172、194、271、293、370、392、491、590
代碼測試
@Test
public void test_Iterator() {
Map<String, String> map = new HashMap<String, String>(64);
map.put("24", "Idx：2");
map.put("46", "Idx：2");
map.put("68", "Idx：2");
map.put("29", "Idx：7");
map.put("150", "Idx：12");
map.put("172", "Idx：12");
map.put("194", "Idx：12");
map.put("271", "Idx：12");
System.out.println("排序01：");
for (String key : map.keySet()) {
System.out.print(key + " ");
}
map.put("293", "Idx：12");
map.put("370", "Idx：12");
map.put("392", "Idx：12");
map.put("491", "Idx：12");
map.put("590", "Idx：12");
System.out.println("\n\n排序02：");
for (String key : map.keySet()) {
System.out.print(key + " ");
}
map.remove("293");
map.remove("370");
map.remove("392");
map.remove("491");
map.remove("590");
System.out.println("\n\n排序03：");
for (String key : map.keySet()) {
System.out.print(key + " ");
}
}
這段代碼分別測試了三種場景，如下；
- 添加元素，在HashMap還是只鏈表結構時，輸出測試結果01
- 添加元素，在HashMap轉換為紅黑樹時候，輸出測試結果02
- 刪除元素，在HashMap轉換為鏈表結構時，輸出測試結果03
4.3 測試結果分析
排序01：
24 46 68 29 150 172 194 271
排序02：
24 46 68 29 271 150 172 194 293 370 392 491 590
排序03：
24 46 68 29 172 271 150 194
Process finished with exit code 0
從map.keySet()測試結果可以看到，如下信息；
- 01情況下，排序定位哈希值下標和鏈表信息
- 02情況下，因為鏈表轉換為紅黑樹，樹根會移動到數組頭部。
moveRootToFront()方法
- 03情況下，因為刪除了部分元素，紅黑樹退化成鏈表。
三、總結
- 這一篇API源碼以及邏輯與上一篇數據結構中擾動函數、負載因子、散列表實現等，內容的結合，算是把HashMap基本常用技術點，梳理完成了。但知識絕不止於此，這里還有紅黑樹的相關技術內容，后續會進行詳細。
- 除了HashMap以外還有TreeMap、ConcurrentHashMap等，每一個核心類都有一些相關的核心知識點，每一個都非常值得深入研究。這個燒腦的過程，是學習獲得知識的最佳方式。
- 可能關於HashMap還有一些疏漏的點，也希望閱讀的小伙伴可以提出更多的問題，互相學習，共同進步，本文就到這里，感謝您的閱讀！