我們在上一個章節《HashMap原理(一) 概念和底層架構》中講解了HashMap的儲存資料結構以及常用的概念及變數，包括capacity容量，threshold變數和loadFactor變數等。本章主要講解HashMap的擴容機制及存取原理。
先回顧一下基本概念：
table變數：HashMap的底層資料結構，是Node類的實體陣列，用於儲存key-value對；
capacity：並不是一個成員變數，但卻是一個必須要知道的概念，表示容量；
size變數：表示已儲存的HashMap的key-value對的數量；
loadFactor變數：裝載因子，用於衡量滿的程度；
threshold變數：臨界值，當超出該值時，表示table表示該擴容了；
一. put方法
HashMap使用雜湊演算法得到陣列中儲存的位置，然後呼叫put方法將key-value對儲存到table變數中。我們通過圖來演示一下儲存的過程。
簡單解釋一下：
1）通過hash(Object key)演算法得到hash值；
2）判斷table是否為null或者長度為0，如果是執行resize()進行擴容；
3）通過hash值以及table陣列長度得到插入的陣列索引i，判斷陣列table[i]是否為空或為null；
4）如果table[i] == null，直接新建節點新增，轉向 8），如果table[i]不為空，轉向 5）；
5）判斷table[i]的首個元素是否和key一樣，如果相同直接覆蓋value，這裡的相同指的是hashCode以及equals，否則轉向 6）；
6）判斷table[i] 是否為treeNode，即table[i] 是否是紅黑樹，如果是紅黑樹，則直接在樹中插入鍵值對，否則轉7）；
7）遍歷table[i]，判斷連結串列長度是否大於8，大於8的話把連結串列轉換為紅黑樹，在紅黑樹中執行插入操作，否則進行連結串列的插入操作；遍歷過程中若發現key已經存在直接覆蓋value即可；
8）插入成功後，判斷實際存在的鍵值對數量size是否超多了最大容量threshold，如果超過，進行擴容。
我們關注一下這裡面最重要的三個方法，hash()，putVal()，resize().
1. hash方法
我們通過hash方法計算索引，得到陣列中儲存的位置，看一下原始碼
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}我們可以看到HashMap中的hash演算法是通過key的hashcode值與其hashcode右移16位後得到的值進行異或運算得到的，那麼為什麼不直接使用key.hashCode()，而要進行異或操作？我們知道hash的目的是為了得到進行索引，而hash是有可能衝突的，也就是不同的key得到了同樣的hash值，這樣就很容易產業碰撞，如何減少這種情況的發生呢，就通過上述的hash(Object key)演算法將hashcode 與 hashcode的低16位做異或運算，混合了高位和低位得出的最終hash值，衝突的概率就小多了。舉個例子：
有個蒸籠，第一層是豬肉包、牛肉包、雞肉包，第二層是白菜包，第三層是豆沙包，第四層是香菇包。這時你來買早餐，你指著第一層說除了豬肉包，隨便給我一個包子，因為外表無法分辨，這時拿到豬肉包的概率就有1/3，如果將二層、三層、四層與一層混合在一起了，那麼拿到豬肉包的概率就小多了。
我們的hash(Object key)演算法一個道理，最終的hash值混合了高位和低位的資訊，摻雜的元素多了，那麼最終hash值的隨機性越大，而HashMap的table下標依賴於最終hash值與table.length()-1的&運算，這裡的&運算類似於挑包子的過程，自然衝突就小得多了。計算過程如下：
最開始的hashCode： 1111 1111 1111 1111 0100 1100 0000 1010
右移16位的hashCode：0000 0000 0000 0000 1111 1111 1111 1111
異或運算後的hash值： 1111 1111 1111 1111 1011 0011 1111 0101
2. putVal方法
通過putVal方法將傳遞的key-value對新增到陣列table中。
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
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的table陣列還未定義或者還未初始化其長度，則先通過resize()進行擴容,
* 返回擴容後的陣列長度n
*/
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//通過陣列長度與hash值做按位與&運算得到對應陣列下標，若該位置沒有元素，則new Node直接將新元素插入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//否則該位置已經有元素了，我們就需要進行一些其他操作
else {
Node<K,V> e; K k;
//如果插入的key和原來的key相同，則替換一下就完事了
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
/**
* 否則key不同的情況下，判斷當前Node是否是TreeNode,如果是則執行putTreeVal將新的元素插入
* 到紅黑樹上。
*/
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//如果不是TreeNode,則進行連結串列遍歷
else {
for (int binCount = 0; ; ++binCount) {
/**
* 在連結串列最後一個節點之後並沒有找到相同的元素，則進行下面的操作，直接new Node插入，
* 但條件判斷有可能轉化為紅黑樹
*/
if ((e = p.next) == null) {
//直接new了一個Node
p.next = newNode(hash, key, value, null);
/**
* TREEIFY_THRESHOLD=8,因為binCount從0開始，也即是連結串列長度超過8（包含）時，
* 轉為紅黑樹。
*/
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
/**
* 如果在連結串列的最後一個節點之前找到key值相同的（和上面的判斷不衝突，上面是直接通過陣列
* 下標判斷key值是否相同），則替換
*/
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;
//onlyIfAbsent為true時:當某個位置已經存在元素時不去覆蓋
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//最後判斷臨界值，是否擴容。
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}3. resize方法
HashMap通過resize()方法進行擴容，容量規則為2的冪次
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//以前的容量大於0，也就是hashMap中已經有元素了，或者new物件的時候設定了初始容量
if (oldCap > 0) {
//如果以前的容量大於限制的最大容量1<<30,則設定臨界值為int的最大值2^31-1
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
/**
* 如果以前容量的2倍小於限制的最大容量，同時大於或等於預設的容量16，則設定臨界值為以前臨界值的2
* 倍，因為threshold = loadFactor*capacity，capacity擴大了2倍，loadFactor不變，
* threshold自然也擴大2倍。
*/
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
/**
* 在HashMap構造器Hash(int initialCapacity, float loadFactor)中有一句程式碼，this.threshold
* = tableSizeFor(initialCapacity)， 表示在呼叫構造器時，預設是將初始容量暫時賦值給了
* threshold臨界值，因此此處相當於將上一次的初始容量賦值給了新的容量。什麼情況下會執行到這句？當呼叫
* 了HashMap(int initialCapacity)構造器，還沒有新增元素時
*/
else if (oldThr > 0)
newCap = oldThr;
/**
* 呼叫了預設構造器，初始容量沒有設定，因此使用預設容量DEFAULT_INITIAL_CAPACITY（16），臨界值
* 就是16*0.75
*/
else {
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//對臨界值做判斷，確保其不為0，因為在上面第二種情況(oldThr > 0)，並沒有計算newThr
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
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;
//沒有連結串列Node節點，直接放到新的table中下標為【e.hash & (newCap - 1)】位置即可
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//如果是treeNode節點，則樹上的節點放到newTab中
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//如果e後面還有連結串列節點，則遍歷e所在的連結串列，
else { // 保證順序
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
//記錄下一個節點
next = e.next;
/**
* newTab的容量是以前舊錶容量的兩倍,因為陣列table下標並不是根據迴圈逐步遞增
* 的，而是通過（table.length-1）& hash計算得到，因此擴容後，存放的位置就
* 可能發生變化，那麼到底發生怎樣的變化呢，就是由下面的演算法得到.
*
* 通過e.hash & oldCap來判斷節點位置通過再次hash演算法後，是否會發生改變，如
* 果為0表示不會發生改變，如果為1表示會發生改變。到底怎麼理解呢，舉個例子：
* e.hash = 13 二進位制：0000 1101
* oldCap = 32 二進位制：0001 0000
* &運算： 0 二進位制：0000 0000
* 結論：元素位置在擴容後不會發生改變
*/
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
/**
* e.hash = 18 二進位制：0001 0010
* oldCap = 32 二進位制：0001 0000
* &運算： 32 二進位制：0001 0000
* 結論：元素位置在擴容後會發生改變，那麼如何改變呢？
* newCap = 64 二進位制：0010 0000
* 通過(newCap-1)&hash
* 即0001 1111 & 0001 0010 得0001 0010，32+2 = 34
*/
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
/**
* 若(e.hash & oldCap) == 0，下標不變，將原表某個下標的元素放到擴容表同樣
* 下標的位置上
*/
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
/**
* 若(e.hash & oldCap) != 0，將原表某個下標的元素放到擴容表中
* [下標+增加的擴容量]的位置上
*/
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}二. get方法
我們先簡單說一下get(Object key)流程，通過傳入的key通過hash()演算法得到hash值，在通過(n - 1) & hash找到陣列下標，如果陣列下標所對應的node值正好key一樣就返回，否則找到node.next找到下一個節點，看是否是treenNode，如果是，遍歷紅黑樹找到對應node，如果不是遍歷連結串列找到node。我們看一下原始碼
public V get(Object key) {
Node<K,V> e;
//先通過hash(key)找到hash值，然後呼叫getNode(hash,key)找到節點
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//通過(n - 1) & hash找到陣列對應位置上的第一個node
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果這個node剛好key值相同，直接返回
if (first.hash == hash &&
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//如果不相同就再往下找
if ((e = first.next) != null) {
//如果是treeNode，就遍歷紅黑樹找到對應node
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//如果是連結串列，遍歷連結串列找到對應node
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}這幾個方法是核心，雖然HashMap還有很多常用方法，不過大體和這幾個方法有關，或者實現邏輯相似，這裡就不再多說了。
三. 總結
本文在上一章基本概念和底層結構的基礎上，從原始碼的角度講解了擴容機制以及存取原理，主要分析了put方法和get方法，put方法的核心為hash()，putVal()，resize()，get方法的核心為getNode()，若有不對之處，請批評指正，望共同進步，謝謝！