JDK1.8原始碼逐字逐句帶你理解HashMap底層（2）
引言：
很開心，大家繼續來看HashMap底層的第二段。昨天（上一篇博文）我們主要是介紹了HashMap類的一些重要的成員變數並簡述了他們的名稱作用，附帶圖文解釋了他們之間存在的關係，又深入學習了HashMap儲存的發展和結構，以一個簡單的demo描述了HashMap的初始化和各個變數的變化情況。今天主要是從HashMap的原始碼入手，我會逐字逐句的解釋每一種情況中HashMap幹了些什麼。為了大家更好的理解，我會適當拓展一下和HashMap底層相關的一些技術話題，所以，在博文中“技術點”這個模組將會讓你對整個博文理解更深刻哦。如果是新來的朋友，可以檢視我的博文目錄尋找上半篇，同時目前的博文都是面試高頻出現的哦，大家可以點選連結：
技術點：
1、演算法複雜度（時間複雜度和空間複雜度）
①空間複雜度是指執行一個程式所需要的記憶體大小，主要用於估計程式執行所需記憶體大小。主要分為固定部分和可變部分，固定部分是指程式碼、常量、簡單變數等所佔的空間，可變部分主要演算法輸入、程式執行所需要的額外空間。一般來說降低空間複雜度可以考慮壓縮儲存技術。
②時間複雜度用O(f(n))表示，主要是用於描述演算法執行效率高低。它是面試當中經常會遇到的筆試題，比如說給你一段程式，要求你求得該段程式的時間複雜度。筆者不想去解釋它的定義了，因為會讓大家反而變得看不懂，我先從小到大列出常見的時間複雜度，然後給幾個程式碼片段來一起求複雜度。
常見時間複雜度
其實在我們一般程式設計中寫演算法的時候會以O(n)為界限，如上圖坡度越小，效率越好，我們越喜歡。但是那些爆炸式的時間複雜度肯定也存在意義，比如說天文計算等等。接下來，我們用幾個例子說明如何計算時間複雜度：
for (int i = 0; i < n; i++) { //2
j++; //3
}其中語句2執行n+1次，語句3執行n次(之所以語句2會多執行一次是因為語句不符合的時候還會進行一次執行判斷)
那麼時間複雜度就是O(n+1+n)= O(2n+1)=O(n)。為什麼直接就等於O(n)了呢？因為我們只要保證基本語句執行次數的函式中的最高次冪正確即可，可以忽略所有低次冪和最高次冪的係數。所以如果熟練之後只需要看最裡面的語句的執行頻度就可以確定階級了。在比如：
for (int i = 0; i < n; i++) { //1
for(int j = 0; j<n; j++){ //2
k++; //3
}
}上面程式碼段中有兩個for迴圈。語句1執行n+1次，語句2執行n*(n+1)次，語句3執行n*n次。所以他們的時間複雜度就是O(n+1+n*(n+1)+n^2) = O(2n^2+2n+1)=O(n^2).
時間複雜度就寫到這裡了，篇幅太長不好，有興趣可以自己去找資料研究噠。
在HashMap中組數裡面添加了連結串列，就是一種時間複雜度換空間複雜度的一種方式。合理配置時間複雜度和空間複雜度會使得程式更加的健壯。
2、紅黑樹
紅黑樹是自平衡的二叉查詢樹(有序二叉樹)，一般的二叉查詢樹的時間複雜度為O(lgn)，當一般的二叉查詢樹退化之後會變成一個線性的列表，這個時候它的時間複雜度就變為了O(n)(這個O(n)其實就是for迴圈/遍歷一次)，但是紅黑樹它所獨有的著色和自平衡的一些性質使得時間複雜度最壞為O(logn)，而不是更低的O(n)，這就是等下我們要說的為什麼HashMap在JDK1.8的時候引入衝突解決方案要用紅黑樹。對於紅黑樹，筆者在簡單的說一下大致性質：
從圖中就可以看到：①對於任意一個節點，它的左子節點比它小，右子節點比它大， 其實它還有更多的性質。我們就不一一研究了。我們只需要知道這一條性質和紅黑樹的優勢就是可以自平衡。注意，本部落格中提到的樹性質就是①。
節點插入:遍歷樹，根據上面描述的性質，只要根據key值的大小可以很快定位到新要插入的節點位置。如果插入破壞了紅黑樹本身的平衡，紅黑樹會進行旋轉，重新著色進行調整。
節點刪除：分為3種情況。①第一要刪除的節點處於最外層，那麼就可以直接刪除。②如果它存在一個子節點，這個子節點直接頂替要刪除的節點後並不會破壞整棵樹的性質，③如果它存在兩個子節點，就先需要拿後繼節點來頂替它的位置，在把該節點刪除。那小夥伴說什麼是後繼節點？就上圖而言，根節點13的後繼節點就是11和15，也就是說節點左邊最靠右的，和右邊最靠左的。我這麼說不知道能否理解吶？刪除之後也可能會重新調整樹本身的平衡。
3、HashMap衝突：
首先，我們說一下“桶”的概念，桶在前一篇博文中就是arr中的某一個，在上一篇博文的圖中arr[0]~arr[15]總共就是16個桶。如果hash(key)%length會確定這個物件儲存在哪個桶當中。那麼如果經過計算髮現兩個物件都在同一個桶中，那麼我們就說這兩個物件在HashMap儲存中衝突了。假如衝突非常嚴重，那麼時間複雜度就演變成O(n)了(不考慮衝突解決)。
4、&與%：
因為在HashMap中並不會用%來表達取模運算，而是要用&來運算。也就是一定要記住如下等式：
A%B = A&(B-1)，原始碼中計算桶的位置都是用&來計算的，記住這個，看原始碼就會輕鬆一些。
HaspMap逐字逐句解讀底層
1、紅黑樹原始碼(筆者裁剪了一部分)：
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; //父節點
TreeNode<K,V> left;//左子節點
TreeNode<K,V> right;//右子節點
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red; //節點顏色
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
}2、核心hashMap
我會在每個關鍵的if前面新增進入這個if的條件，幫助大家理解
//reszie()方法：
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; //定義舊錶並把原本的賦值給他，從昨天的博文中可以知道new了一個HashMap物件之後其實table是為null的。
int oldCap = (oldTab == null) ? 0 : oldTab.length;//如果舊錶容量為null就初始0
int oldThr = threshold;//舊錶的閥值
int newCap, newThr = 0;//定義新表的容量和新表的閥值
//進入條件：正常擴容
if (oldCap > 0) {如果舊錶容量大於0，這個情況就是要擴容了
//進入條件：已達到最大，無法擴容
if (oldCap >= MAXIMUM_CAPACITY) {//如果容量已經大於等於1<<30
threshold = Integer.MAX_VALUE;//設定閥值最大
return oldTab;//直接返回原本的物件(無法擴大了)
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)//舊錶容量左移一位<<1,且移動之後處於合法的範圍之中。新表容量擴充完成
newThr = oldThr << 1; // 新表的閥值也擴大一倍。
}
//進入條件：初始化的時候使用了自定義載入因子的建構函式
else if (oldThr > 0) // 這裡如果執行的情況是原表容量為0的時候，但是閥值又不為0。hashmap的建構函式不同（需要設定自己的載入因子）的時候會觸發。
newCap = oldThr;
//進入條件：呼叫無參或者一個引數的建構函式進入預設初始化
else { // 如果HashMap預設構造就會進入下面這個初始化，我們昨天（上一篇博文）的第一次put就會進入下面這一塊。
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"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//進入條件：原表存在
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {//開始遍歷
oldTab[j] = null;//舊錶原本置空
if (e.next == null)//不存在下個節點，也就是目前put的就是連結串列頭
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;//獲取下一個物件資訊
//因為桶已經擴容了兩倍，所以以下部分是按一定邏輯的把一個連結串列拆分為兩個連結串列，放入對應桶中。具體的拆分流程，各位看官們仔細研究下。筆者已經看得頭暈了。
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;
}
//put方法：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//putVal()方法：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//進入條件:HashMap初始化
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;
//進入條件：判斷桶中第一個是否有相同的key值
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) {
//進入條件：判斷當前桶中物件儲存是否達到8個，如果達到了就進入treeifyBin方法，這裡不再進入方法詳解。大致就是進入之後再判斷當前hashMap的長度，如果不足64，只進行擴容，如果達到64就需要構建紅黑樹了。
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//進入條件：遍歷中檢視是否有相同的key值。如果有直接結束遍歷並賦值
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//進入條件：如果連結串列上有相同的key值。進行替換
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)//這句筆者理解半天也未有所獲，如果誰能清楚知道可以聯絡筆者一起探討
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//如果hashMap的大小大於閥值就需要擴容操作
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
//get()方法：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
getNode()方法：
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//進入條件：如果HashMap不為空，且求得的陣列下標那個物件不為空（關於%和&的關係上面方法已有講過）
if ((tab = table) != null && (n = tab.length) > 0 &&
(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) {
if (first instanceof TreeNode)//如果頭連結串列已經是紅黑樹構造就需要用紅黑樹的方法去遍歷
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//直到找到擁有相同key的時候返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}尾記：
這樣一來我們既清楚了HashMap底層大致是怎麼執行的，同時也清楚了它所相關的一些技術點。希望在以後的學習、面試和工作中對大家有用。如果博文存在什麼問題，請大家和我聯絡。
下面是我的微信二維碼：
