基於哈希表的 Map 接口的實現。此實現提供所有可選的映射操作，並允許使用 null 值和 null 鍵。（除了非同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）此類不保證映射的順序，特別是它不保證該順序恆久不變。 此實現假定哈希函數將元素適當地分佈在各桶之間，可爲基本操作（get 和 put）提供穩定的性能。迭代 collection 視圖所需的時間與 HashMap 實例的“容量”（桶的數量）及其大小（鍵-值映射關係數）成比例。所以，如果迭代性能很重要，則不要將初始容量設置得太高（或將加載因子設置得太低）
–摘自《百度百科》
前言
一步一步，一小步，一大步，我相信知識的積累會有一個質的飛躍。
寫此文章的目的是爲了記錄自己的學習。記錄在此也是希望各位業界的前輩們如果發現了不正確的地方，希望您能及時批評指正，在此感謝!
本篇內容
在上一篇的文章中,粗略的介紹了HashMap中幾個主要的基本概念。
有感興趣的朋友可以去支持一下。如若發現了問題,也希望您能及時糾正。
本篇的內容是接着上一篇文章繼續深入瞭解一下HashMap的擴容機制。
既然瞭解到擴容,我們當然離不開數據結構。JDK1.8之前HashMap由組數+鏈表組成，引入的鏈表的目的主要是爲了解決哈希衝突(當我put的時候HashMap會將我們的key進行哈希算法,然後將此哈希值作爲索引存入數組中,既然是隨機生成的數就會存在概率性,當兩個key的哈希相等時此時就會引入鏈表)，在JDK1.8之後對於解決Hash衝突有了較大的變化，當鏈表長度大於閾值(默認爲8)並且當前數組長度大於64時候，此時該索引上的數據轉化爲紅黑樹存儲，否則還是進行擴容
JDK1.8中必須是同時滿足以上兩個條件。
先看看JDK中的源碼。
也就是說,當鏈表的長度達到給出的閾值8時,會調用treeifyBin方法,在treeifyBin方法中會再次進行一次判斷,如果不滿足最小數組長度會調用resize()方法進行擴容。
本篇文章主要是針對resize()，先了解一下HashMap的擴容是如何執行的。
一、當我們put(k,v)的時候發生了什麼？
//這是JDK中的方法。
/**
* 參數：
* hash(key):把key進行hash計算,用來當做索引
* key | value : 傳入鍵值對
* onlyIfAbsent:boolean類型,如果爲true則不能對值進行覆蓋
* evict:如果爲false表示處於創建模式。
* onlyIfAbsent和evict是一個判斷的依據不需要我們進行傳參,因此我們也只需要它的用處即可。
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
我們可以看到在put方法的內部實際上是調用了putVal()方法。
二、putVal（）是如何擴容的.
實際上進行擴容操作的並不是putVal()，而是resize(),咱們在閱讀源碼的習慣也是逐級往下挖掘。所以我們就遵循這個邏輯。首先來看一下putVal()中是如何調用Resize().
//聲明兩個Node數組,JDK1.8是Node 1.8之前使用的Entry
Node<K,V>[] tab; Node<K,V> p; int n, i;
//新數組,進行初始化得到數組
if ((tab = table) == null || (n = tab.length) == 0)
//得到初始化數組和長度,第一次擴容
n = (tab = resize()).length;
pubVal方法中的內容當然不止於此，在此之前我們需要了解resize()的擴容機制，接下來就煩請大家往下挪一挪先看第三節的內容（若有不便，還請多多海涵.）
下面再來看看putVal方法,該方法大部分是普通的邏輯沒有特別之處,注意的是在最後會再次調用resize（）。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//聲明兩個Node數組,JDK1.8是Node 1.8之前使用的Entry
Node<K,V>[] tab; Node<K,V> p; int n, i;
//新數組,進行初始化得到數組
if ((tab = table) == null || (n = tab.length) == 0)
//得到初始化數組和長度
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)//根據hash值獲取該節點是否爲空,是的話新建一個節點
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//說明hash值入新put的元素hash相等,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) {
//表示此處只有一個頭節點
if ((e = p.next) == null) {
//那麼直接新建一個節點
p.next = newNode(hash, key, value, null);
//如果鏈表的長度大於8,則將鏈表轉爲紅黑樹
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//更新p
p = e;
}
}
//如果存在那麼就覆蓋
if (e != null) {
V oldValue = e.value;
// 判斷是否允許覆蓋，並且value是否爲空
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 回調以允許LinkedHashMap後置操作
afterNodeAccess(e);
return oldValue;
}
}
++modCount; // 更改操作次數
if (++size > threshold) // 大於臨界值
// 將數組大小設置爲原來的2倍，並將原先的數組中的元素放到新數組中
// 因爲有鏈表，紅黑樹之類，因此還要調整他們
resize(); //擴容
// 回調以允許LinkedHashMap後置操作
afterNodeInsertion(evict);
return null;
}
三、resize（）的擴容。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; //未使用put之前的原始數組
int oldCap = (oldTab == null) ? 0 : oldTab.length; //第一次初始化時爲0，否則返回原始數組容量
int oldThr = threshold; //臨界值,
int newCap, newThr = 0; //聲明一個新的容量和閾值
if (oldCap > 0) { //原始數組長度大於0
//原始容量大於等於最大容量,則返回原數組，並且擴容臨界值保持不變,否則進行擴容一倍
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//oldCap<<1 擴大一倍長度小於最大容量並且原始數組要大於等於默認容量
//將臨界值翻倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // 將初始容量設置爲閾值
newCap = oldThr;
else {
//第一次初始化使用默認的初始容量和閾值
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;
/*
上面的操作的結果就是以下兩點
1.如果是第一次進行put的時候(新數組)：
1.1、如果初始化的時候帶了參數
（HashMap(int initialCapacity, float loadFactor)），
那麼newCap就是你的initialCapacity參數
threshold就是 (int)(initialCapacity*loadFactor)
1.2、否則就按默認的算 initialCapacity = 16，threshold = 12
2.如果已經有元素了，那麼直接擴容2倍，如果
oldCap >= DEFAULT_INITIAL_CAPACITY了，那麼threshold也擴大兩倍
*/
//創建hash表
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//變量hash表
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;//臨時節點
if ((e = oldTab[j]) != null) { //如果舊的hash表當前存在節點,賦值給臨時節點e
oldTab[j] = null;//刪除舊的節點
if (e.next == null)//取出來的節點不存在下一個值,將該節點賦值給新的數組,並重新計算hash值作爲key,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中
loHead = e;
else //鏈表追加
loTail.next = e;
loTail = e; //lotail
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null); //該鏈表中還存在next時繼續遍歷
//遍歷結束後
if (loTail != null) {
//在lo中的元素索引位置不變,賦值給新數組
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
//在hi中的元素位置改變,爲原始容量+原始索引
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
對以上方法的解釋（從上到下說 屬於個人見解若有不對,希望及時指出,建議和源碼一塊看）：
/**
* 1.
* 如果oldCap=0 說明是一個新的數組,否則是一個有長度的數組。
* oldTable是我們原始數組(put之前的)
*/
int oldCap = (oldTab == null) ? 0 : oldTab.length
/**
* 2.
* oldCap大於0說明是有長度的數組。
* 判斷爲true:原始容量大於等於最大容量,則返回原數組，並且擴容臨界值保持不變,否則進行擴容一倍
* 爲false：oldCap<<1 擴大一倍長度小於最大容量並且原始數組要大於等於默認容量，將臨界值翻倍
* 關於位運算符這裏簡單說下，大佬可以忽略
* 例如:十進制的2
* 0000 0010
* <<1 0000 0100 ->十進制4
* <<1 0000 1000 ->十進制8
* <<1 0001 0000 ->十進制16
* 可以總結一下以上規律:
* 移一次:2*2->移一次:2*2*2->移一次:2*2*2*2等價於
* 2*(2^1)->2*(2^2)->2*(2^3).....2*(2^n)
* 明白這個之後對於<<1結果是擴大一倍相信應該不難理解了。
*/
if (oldCap > 0) {return "爲了不佔位置省略代碼,可以對照上面源碼看,建議用idea打開源碼觀看"}
/**
* 3.
* 既然是else if 說明 if(oldCap>0)爲false，即:這是一個新的數組
* 將初始容量設置爲閾值(此時的閾值還沒有與加載因子相乘)
*/
else if (oldThr > 0)
else{
//第一次初始化和第一次擴容
}
/**
* 4.以下重點
* 主要對if(oldTab != null){}進行說明,大致的意思在本節開始都做了註釋。下面會着重說一下
* 重要的部分
*/
//原始數組不爲空
if (oldTab != null) {
//1.
else if (e instanceof TreeNode) //轉爲紅黑樹
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
//此處是擴容的重點,
/**
* 擴容之後就是將現有數組節點的內容移到新的數組中,鏈表的設計原則是繼續上下節點的
* 信息。那麼HashMap是如何實現的呢?
* 在此處先舉個例子,我們在上面的也可以看到HashMap中的索引的計算是
* [e.hash&(newcap-1)]
* 擴容之後的大小時原來的2倍,假設現在的容量是16擴容到32,原數組中的索引只會有2
* 種可能,變或不變。
* 不變的索引:存放在低拉鍊表中,也就中else中聲明的
* (Node<K,V> loHead = null, loTail = null),低拉鍊表中的數據會轉移到新數組中且
* 索引保持不變
* 變的索引:存放在高拉鍊表中,也就是esle中聲明的
* (Node<K,V> hiHead = null, hiTail = null),高拉鍊表中的數據在新數組中且新索引
* 是舊的索引+oldCap舊的容量
* --假設舊的節點中某個節點的hash是15,舊的容量是16.(e.hash & oldCap) == 0肯定是
* true爲什麼呢,對& 與做個說明(大佬可以忽略此處)：兩個都爲1纔是1
* 0000 0010 ->屬性2的次冪值,都只有一個高位1,其餘位肯定是0.
* 16-> 0001 0000
* 15-> 0000 1111
* 0000 0000
* 如果(e.hash & oldCap) == 0爲false說明此索引的位置需要發生變化,發生變化的索引
* 位置是舊的索引15+舊的容量16 = 31 位置相同
* 在此處你能發現 [e.hash&(newcap-1)]的妙處了,爲什麼不是[e.hash&(oldcap-1)]
* 假設hash此時爲16,[e.hash&(oldcap-1)] = 0 [e.hash&(newcap-1)] = 16
* 這樣處理在擴容的同時解決了hash的衝突並且可以很快的計算出新的索引位置.
* 不用糾結爲什麼要(e.hash & oldCap) == 0這樣判斷,因爲你不得不承認JDK作者位運算符用的真的給跪了.
* 在遍歷結束後會將在lo中的元素索引位置不變,賦值給新數組
* 在hi中的元素位置改變,爲原始容量+原始索引
*
* 再回到第二節中繼續看putVal方法
*
*/
}
}
上一篇:深入理解HashMap的底層原理(一)粗略的介紹了HashMap中的主要變量和方法,有興趣的朋友可以幫忙一起探討指正不足之處.
如果有不正確,希望大佬們能及時糾正,再次感謝.