品HashMap（java8）
前言
作為java開發人員，HashMap可謂是業務中的一把利器，9龍再次撿起這老生常談的知識點，深入原始碼，細細品味。
首先，我們丟擲幾個關於HashMap的問題，帶著問題去學習，就像捉迷藏一樣有意思。
1、為什麼要使用HashMap？HashMap有什麼特性？
2、HashMap的主要引數有哪些？都有什麼作用？
3、HashMap是基於什麼資料結構實現的？
4、構造HashMap時傳入的初始容量是如何處理的？為什麼要這樣做？
5、HashMap在什麼時候擴容？擴容的時候都做了什麼事？hash碰撞8次一定會轉換為紅黑樹嗎？
6、在foreach時對hashMap進行增刪操作會發生什麼？
1、為什麼要使用HashMap?
我們在使用一種工具的時候，肯定是因為其的某種特性很符合我們的需求，能夠快速準確的解決我們的問題。那我們為什麼要使用HashMap呢？
This implementation provides constant-time performance for the basic operations (get and put),assuming the hash function disperses the elements properly among the buckets.
原始碼註釋裡有這樣一句話，這就是我們使用HashMap的原因。
意為：HashMap為基本操作(get和put)提供了常數時間效能（即O(1)）
我們可以這樣理解，如果當你需要快速儲存並查詢值，可以使用HashMap，它可以保證在O(1)的時間複雜度完成。前提是你鍵的hashCode要足夠不同。
Map還有一個特性就是key不允許重複。下面我們就來看看HashMap如何保證O(1)進行get和put。
2、細嚼HashMap主要引數
2.1、靜態常量
//預設的初始化桶容量，必須是2的冪次方（後面會說為什麼）
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大桶容量
int MAXIMUM_CAPACITY = 30
//預設的負載因子
float DEFAULT_LOAD_FACTOR = 0.75f;
//判斷是否將連結串列轉化為樹的閾值
int TREEIFY_THRESHOLD = 8;
//判斷是否將樹轉化為連結串列的閾值
int UNTREEIFY_THRESHOLD = 6;
//判斷是否可以執行將連結串列轉化為樹，如果當前桶的容量小於此值，則進行resize()。避免表容量過小，較容易產生hash碰撞。
int MIN_TREEIFY_CAPACITY = 64;
複製程式碼2.2、欄位
//hash表
transient Node<K,V>[] table;
//快取的EntrySet，便與迭代使用
transient Set<Map.Entry<K,V>> entrySet;
//記錄HashMap中鍵值對的數量
transient int size;
//當對hashMap進行一次結構上的變更，會進行加1。結構變更指的是對Hash表的增刪操作。
int modCount;
//判斷是否擴容的閾值。threshold = capacity * load factor
int threshold;
//負載因子，用於計算threshold，可以在建構函式時指定。
float loadFactor;
複製程式碼3、嗅探HashMap資料結構
上面我們看到一個Node[] table的Node陣列。
為什麼要使用陣列呢？
答：為了能快速訪問元素。哦，說的什麼鬼，那我得追問，為什麼陣列能快速訪問元素了？
- 陣列只需對 [首地址+元素大小*k] 就能找到第k個元素的地址，對其取地址就能獲得該元素。
- CPU快取會把一片連續的記憶體空間讀入，因為陣列結構是連續的記憶體地址，所以陣列全部或者部分元素被連續存在CPU快取裡面。
讓我們看看Node的結構。
static class Node<K,V> implements Map.Entry<V> {
int hash; //key 的hash
final K key; //key物件
V value; //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;
}
}
複製程式碼我們看到，Node節點內部保留了一個next節點的引用，太熟悉了，這不就是連結串列嘛。
到這，我們知道了HashMap的底層資料結構是基於陣列+連結串列。但是，這就完了嗎？在jdk1.7確實只是這樣，jdk1.8為了提高hash碰撞時連結串列查詢效率低的問題，在hash碰撞達到8次之後會將連結串列轉化為紅黑樹，以至於將連結串列查詢的時間複雜度從O(N)提高到O(logN)。
到這我們就可以明白，HashMap如果能夠均勻的將Node節點放置到table陣列中，我們只要能夠通過某種方式知道指定key的Node所在陣列中的索引，基於陣列，我們就可以很快查詢到所需的值。
接著我們就要看看如何定位到table陣列中。
4、走進HashMap建構函式
有了上面的基礎知識，知道欄位含義及資料結構，我們就有一點信心可以正式進入原始碼閱讀。我覺得了解一個類，得從建構函式入手，知道構造物件的時候做了哪些初始化工作，其次再深入常用的方法，抽絲剝繭。
public HashMap(int initialCapacity) {
//如果只傳入初始值，則負載因子使用預設的0.75
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//保證初始容量最大為2^30
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
"Illegal load factor: " +
loadFactor);
//使用指定的值初始化負載因子及判斷是否擴容的閾值。
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
複製程式碼我們可以看到，建構函式主要是為了初始化負載因子及hash表的容量。可能大家會疑問，這不是初始化的是threshold嗎？不要被表面所欺騙，這只是臨時將hash表的容量儲存在threshold上，我想是因為HashMap不想增加多餘的欄位來儲存hash表的容量，因為陣列的length就可以表示，只是暫時陣列還未初始化，所以容量暫先儲存在threshold。
我們看到將使用者指定的initialCapacity傳入tableSizeFor方法返回了一個值，返回的值才是真正初始化的容量。？？？搞毛子這是？然我們揭開它神祕的面紗。
/**
* Returns a power of two size for the given target capacity.
*/
int tableSizeForint cap) {
int n = cap - 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
複製程式碼好吧， 我們還是把它蓋上吧，9龍也沒去推算過。我們從jdk給的方法註釋看出，該方法返回一個目標值的2的冪次方，進一步9龍翻譯為：返回大於或等於目標值的第一個數，該數必須是2的冪次方。
舉例說一下：
如果輸入10，大於等於10的第一個數，又是2的冪次方的數是16；
如果輸入7，大於等於7的第一個數，又是2的冪次方的數是8；
如果輸入20；大於等於20的第一個數，又是2的冪次方的是32；
到這我們又得問自己，為什麼hash表的容量必須是2的冪次方呢？
5、解剖HashMap主要方法
5.1、put
當我們new出HashMa的物件，都會呼叫put方法進行新增鍵值對。我跟那些直接貼程式碼的能一樣嗎？有啥不一樣，哈哈哈。9龍會先讀原始碼，再貼流程圖，這樣大家會更理解一點。
public V put(K key, V value) {
return putVal(hash(key), key, value,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">false,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">true);
}
hash(Object key) {
int h;
//將key的高16位與低16位異或，減小hash碰撞的機率
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
複製程式碼讓我們看看putVal幹了什麼。
/**
* 此方法用於將(k,v)鍵值對儲存到HashMap中
*
* @param hash key的hash
* @param key key物件
* @param value key對應的value物件
* @param onlyIfAbsent 如果是true,則不覆蓋原值。
* @param evict if false, the table is in creation mode.
* @return 返回舊值，如果沒有，則返回null。
*/
final V putValboolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//在第一次put的時候，此時Node表還未初始化，上面我們已經知道，構造HashMap物件時只是初始化了負載因子及初始容量，但並沒有初始化hash表。在這裡會進行第一次的初始化操作。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果得到了一個hash值，並且hash值在很少相同的情況下，如何均勻的分佈到table陣列裡呢？最容易想到的就是用hash%n，n為table陣列的長度。但是%運算是很慢的，我們知道位運算才是最快的，計算機識別的都是二進位制。所以如果保證n為2的冪次方，hash%n 與 hash&(n-1)的結果就是相同的。這就是為什麼初始容量要是2的冪次方的原因。
//當找到的hash桶位沒有值時，直接構建一個Node進行插入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">null);
else {
//否則，表明hash碰撞產生。
Node<K,V> e; K k;
//判斷hash是否與桶槽的節點hash是否相同並且key的equals方法也為true,表明是重複的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, value);
else {
//表明是連結串列，還未轉換為紅黑樹。
for (int binCount = 0; ; ++binCount) {
//如果節點的next索引是null，表明後面沒有節點，則使用尾插法進行插入
if ((e = p.next) == null) {
p.next = newNode(hash,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">null);
//此時連結串列長度為9，即hash碰撞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;
}
}
//判斷是否是重複的key
if (e != null) { // existing mapping for key
//拿到舊值
V oldValue = e.value;
//因為put操作預設的onlyIfAbsent為false，所以，預設都是使用新值覆蓋舊值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//返回舊值
return oldValue;
}
}
//到這裡，表明有新資料插入到Hash表中，則將modCount進行自增
++modCount;
//判斷當前鍵值對容量是否滿足擴容條件，滿足則進行擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
複製程式碼
總結一下：
- put方法先通過計算key的hash值；
- 如果hash表沒有初始化，則進行初始化；
- 然後計算該hash應該處於hash桶的哪個位置；
- 如果該位置沒有值，則直接插入；
- 如果有值，判斷是否為樹節點，是的話插入到紅黑樹中；
- 否則則是連結串列，使用尾插法進行插入，插入後判斷hash碰撞是否滿足8次，如果滿足，則將連結串列轉化為紅黑樹；
- 插入後判斷key是否相同，相同則使用新值覆蓋舊值；
- 進行++modCount，表明插入了新鍵值對；再判斷是否進行擴容。
靈魂拷問：真的hash碰撞8次一定會轉換為紅黑樹嗎？？？
其實不然，在put中，如果hash碰撞8次會呼叫此方法將連結串列轉換為紅黑樹，但不一定呼叫就會真正轉換。需要tab.length大於等於64才會真正的執行轉換操作。因為在表容量過小的時候，hash碰撞才會比較明顯，但不是說表越大越好。
void treeifyBin(Node<K,V>[] tab,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">int hash) {
//如果表的長度小於64，是先擴容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
if ((e = tab[index = (n - 1) & hash]) != null) {
//只有大於等於64才會真正的轉換
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">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);
}
}
複製程式碼5.2、resize()
put方法中用到了兩次resize()方法，現在讓我們來品一品resize()的具體實現邏輯。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//如果舊table中有資料
if (oldCap > 0) {
//當表的長度達到定義的最大值時，不再進行擴容，只是將判斷擴容的閾值改為Integer.MAX_VALUE。
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//先將新容量為原來的2倍，如果結果小於MAXIMUM_CAPACITY並且舊的容量大於等於預設值16，則也將新的閾值為原來的2倍
if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//oldCap等於0 如果舊閾值大於0,則將舊閾值賦值給新容量。這一步對應於指定的容量構造器，指定容量時，賦值給了閾值
if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//這一步對應於無參構造器，這時使用預設值
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//這裡是因為在oldCap大於0但沒有大於預設的16，不會更改newThr的值，還是0。這時候需要根據newCap的值計算newThr。
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//將新閾值覆蓋threshold
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//使用newCap初始化新表。這裡的newCap是oldCap的2倍
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//至此，完成了新表容量的計算及新閾值的計算，並且建立了新表。下面開始將舊錶資料移至新表
if (oldTab != //從表的前往後遷移
int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果下標j對應的位置有值，拿到引用賦值給e
if ((e = oldTab[j]) != null) {
//因為已經有了引用e,可以將原陣列的賦值為null, help gc
oldTab[j] = null;
//如果e.next沒有指向，則證明當前槽位只有一個節點，直接計算在新表的位置賦值即可
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//證明當前槽位不止一個節點，判斷e是否為TreeNode，如果是，則使用樹的遷移方法
if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(else { // preserve order
//因為擴容後的節點不是在j處，就在j + oldCap處。
//loHead節點記錄了j處的連結串列的頭指標，loTail記錄j處尾指標
//hiHead節點記錄了j+oldCap處連結串列的頭指標，hiTail記錄了j+oldCap處的尾指標
Node<K,V> loHead = null;
Node<K,V> hiHead = do {
next = e.next;
//判斷是否還處於j處（後面會詳細解釋）
if ((e.hash & oldCap) == 0) {
if (loTail == null)
//記錄j的頭指標
loHead = e;
else
//連結節點
loTail.next = e;
loTail = e;
}
//否則在[j+oldCap]處
else {
if (hiTail == //記錄j+oldCap的頭指標
hiHead = e;
//連結節點
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
//將位置沒變的連結串列放在j處
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = //將位置改變的連結串列放在[j+oldCap]處
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//返回新連結串列
return newTab;
}
複製程式碼現在我們仔細分析e.hash & oldCap。二話不說，直接上圖。
如此詳細，是不是不點贊都有點過分了。
resize()中我們看到如果是樹節點，呼叫了((TreeNode)e).split(this,newTab,j,oldCap)方法。有了上面的知識，其實這個方法乾的事情是一樣的。將紅黑樹拆分為兩棵子樹，還是分別放置於原來位置和原來位置+oldCap位置。但要注意，這個方法在樹的節點小於等於6的時候會將紅黑樹轉換回連結串列。
split(HashMap<K,V> map,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">int index,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">int bit) {
TreeNode<K,V> b = this;
// Relink into lo and hi lists, preserving order
TreeNode<K,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">null;
TreeNode<K,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">int lc = 0, hc = 0;
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
//判斷位置是否更改
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
if (loHead != null) {
//數量小於等於6，轉換回連結串列
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);
else {
tab[index] = loHead;
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
null)
hiHead.treeify(tab);
}
}
}
複製程式碼到此，resize()方法9龍啃完了，牙好疼啊。
5.2、get
知道了HashMap的資料結構及如何以常數時間將鍵值對put儲存管理的，那get這不是很容易嗎？請大家嚐嚐這道小菜。我們儲存的是鍵值對，儲存的時候都是以key作為條件儲存的，所以在我們取值的時候也是通過key獲取值。
get(Object key) {
Node<K,V> e;
//計算key的hash，用於定位桶的位置
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
getNodeint n; K k;
//如果hash桶有值，並且基於hash繼續的桶位置也存在值
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - //先檢查第一個節點是否匹配，找到則返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//如果第一個不匹配，則判斷next是否存在
if ((e = first.next) != //如果存在，判斷桶節點是否為樹節點，如果是樹節點，則從紅黑樹查詢返回
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//不是樹節點，從連結串列的表頭向表尾依次判斷是否匹配
null && key.equals(k))))
//找到則返回
return e;
} null);
}
}
//沒有找到，則返回null
null;
}
複製程式碼總結一下get流程：
- 更加key計算hash值
- 使用hash&(n-1)判斷hash桶位是否有值，如果沒有值，則返回null
- 如果有值，判斷第一個是否匹配。（匹配指：hash值相同並且equals方法返回結果為true），匹配則返回
- 如果第一個不匹配，判斷是否為樹節點，是樹節點則從紅黑樹查詢
- 如果不是樹節點，則是連結串列，則從表頭到表尾依次查詢。
6、簡述modCount
這個欄位並不是map獨有的，Collection集合（List、Set）也有。此欄位用於迭代時的快速失敗，也就是在迭代的過程中，如果呼叫了put、clear、remove等會對容器內部資料的數量產生增加或減少的操作時，丟擲ConcurrentModificationException異常。
HashMap有三個迭代器，分別是KeyIterator、ValueIterator、EntryIterator，它們分別對應於KeySet、Values、EntrySet內部類中，當使用者呼叫其對應的iterator()方法時都會new一個對應的迭代器。
這裡我就不貼程式碼了，太多，有興趣的可以去看一看。這裡主要講解為什麼快速失敗。
final KeyIterator extends HashIterator
Iterator<K> {
public final K next() { return nextNode().key; }
}
ValueIterator return nextNode().value; }
}
EntryIterator V>> {
final Map.Entry<K,117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">return nextNode(); }
}
複製程式碼使用者可以根據自己的需求選擇使用的迭代器。每一個都繼承自HashIterator，我們來看一看。
abstract HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
HashIterator() {
//關鍵在這裡，當每一次使用迭代器的時候，會將modCount賦值給內部類的expectedModCount
expectedModCount = modCount;
Node<K,V>[] t = table;
current = next = null;
index = if (t != null && size > 0) { // advance to first entry
do {} while (index < t.length && (next = t[index++]) == null);
}
}
boolean hasNext() {
return next != null;
}
nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
//每次取值之前會判斷modCount和expectedModCount是否相等，如果不等則表明在迭代過程中有其他執行緒或當前執行緒呼叫了put、remove等方法。
if (modCount != expectedModCount)
new ConcurrentModificationException();
if (e == null)
new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null);
}
return e;
}
//如果想刪除，只能呼叫迭代器自己的remove方法，但是，它刪除的是呼叫nextNode()拿到的節點
removeif (p == new IllegalStateException();
//刪除之前也會判斷modCount是否被修改
new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key),117); word-wrap: inherit !important; word-break: inherit !important;" class="hljs-keyword">false);
expectedModCount = modCount;
}
}
複製程式碼所以，在迭代過程中對HashMap進行增刪操作會丟擲ConcurrentModificationException異常。還記得一開始提出的一個問題嗎？對的，就是它。你可以去看看List等的原始碼，modCount也存在，而且實現都是一樣的。
7、總結
樓主花了很大的精力與時間與大家細嚼慢嚥HashMap，我想現在大家都知道了最開始的問題的答案了，包括過程中樓主提出的一些問題，也都一一進行了詳解。9龍沒去討論併發條件出現的問題，也不討論1.7併發擴容時連結串列死迴圈問題，網上太多了。更重要是，HashMap本身就不支援併發操作，那你想到了什麼呢？
9龍才疏學淺，文中如有錯誤，敬請指出，也歡迎大家有疑問可以提出，一起探討進步。
如果覺得9龍本文對你有幫助，請幫忙點贊、分享以示支援，如果轉載請註明出處。話不多說，點關注，不迷路。