Java小白的源碼學習系列：HashMap
春節拜年取消，在家花了好多天時間啃一啃HashMap的源碼，同樣是找了很多很多的資料，有JDK1.7的，也有JDK1.8的，當然本文基於JDK1.8。將所學到的東西進行整理，希望回過頭再看的時候，有更深刻的見解。
官方文檔解讀
先來看看史詩級長屏之官方介紹
基本數據結構
實際上，在JDK1.8中，HashMap底層是依據數組+單鏈表+紅黑樹的結構存儲數據的。具體是怎么樣的呢？
HashMap實現了Map接口，維護的是一組組鍵值對，以便於我們根據鍵就能立刻獲取其對應值。另外，HashMap用了特殊的手法，優化了它的性能，我們本篇來具體學習並總結一下。
-
我們知道，數組的結構利於查詢，HashMap依據哈希函數，將元素以某種方式映射到數組的某個位置上，就可以依據數組結構查詢快的特點迅速鎖定目標。
-
但是，哈希函數並不是萬能的，兩個不同的元素完全有可能算出相同的哈希值，這個時候就產生了哈希碰撞。
-
HashMap是如何解決的呢？上面已經提到，采用的是鏈地址法，就是將每個元素看成單鏈表中的節點，都有指向下一個節點的指針。這是一個不錯的辦法，能夠減少重哈希的概率。
-
但，又有一個問題，要是真的出現了極端的情況：有大量的元素通過哈希函數求得的值聚集在同一個鏈表上，這時想要找到這個元素，需要花費大量的時間。JDK1.8中，運用了紅黑樹結構，鏈表中的節點數>TREEIFY_THRESHOLD時，鏈表結構將會轉化為樹形結構，將查找元素的時間復雜度從O(n)降為O(logn)，大大提高了效率。
基本源碼解讀
基本成員變量
再看看HashMap中定義的一些常量：
//序列號
private static final long serialVersionUID = 362498820763181265L;
//默認的初始容量為16（必須為2的冪）
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//允許的最大容量2的30次冪
static final int MAXIMUM_CAPACITY = 1 << 30;
//沒有指定負載因子時，默認為0.75f
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//鏈表轉化為紅黑樹的閾值
static final int TREEIFY_THRESHOLD = 8;
//紅黑樹退化為鏈表的閾值
static final int UNTREEIFY_THRESHOLD = 6;
//數組的容量大於64時，桶才有可能轉化為樹形結構
static final int MIN_TREEIFY_CAPACITY = 64;
還有一些成員變量：
//存儲的元素的數組，數組容量一定時2的冪次
transient Node<K,V>[] table;
//存放具體元素的集
transient Set<Map.Entry<K,V>> entrySet;
//存放元素的個數
transient int size;
//每次更改結構的計數器
transient int modCount;
//閾值，還沒有分配數組時，閾值為默認容量或指定容量，之后該值等於容量*負載因子
int threshold;
//負載因子
final float loadFactor;
構造器
我們根據源碼，來看看在JDK1.8中，這些到底是如何實現的，以及為什么要這樣考慮。
還是先看看其中三個構造器（暫時先忽略最后一個）：
//無參構造器
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//指定容量的構造器
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//兩參構造器
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
//傳入映射集的構造器
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
這就是HashMap中提供的四個構造器，我們從中可以察覺出一些端倪。
- 如果沒有指定負載因子，默認為0.75，且指定的負載因子需要大於0。
- 初始容量並沒有在構造器中直接指定，我們暫時保留疑惑。
- 通過兩個參數的構造器，我們發現通過
tableSizeFor對我們傳入的初始容量進行計算，並為閾值賦值。
巧妙的tableSizeFor
說到這，我們來看看這個巧妙的tableSizeFor，我們通過注解可以知道，這個方法返回的是大於等於傳入值的最小2的冪次方（傳入1時，為1）。它到底是怎么實現的呢，我們來看看具體的源碼：
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
說實話，我再看到這個方法具體實現之后，感嘆了一句，數學好牛！我通過代入具體數字，翻閱了許多關於這部分的文章與視頻，通過簡單的例子，來做一下總結。
-
我們先試想一下，我們想得到比n大的最小2次冪只需要在最高位的前一位置1，后面全置0就ok了吧。如0101代表的是5，1000就符合我們的需求為8。
-
我們再傳入更大的數，為了寫着方便，這里就以8位為例：
-
第一步
int n = cap -1這一步其實是為了防止cap本身為2的冪次的情況，如果沒有這一步的話，在一頓操作之后，會出現翻倍的情況。比如傳入為8，算出來會是16，所以事先減去1，保證結果。 -
最后n<0的情況的判定，排除了傳入容量為0的情況。
-
n>=MAXIMUM_CAPACITY的情況的判定，排除了移位和或運算之后全部為1的情況。
講到這里，我知道了為什么數組的容量總是2的冪次數了：是因為運算規定,但是這基本不算是原因，選擇2的冪次方數一定有出於便利的方面的原因，這部分我們待會再說。
我們在分析成員變量的時候說過，
threshold是用來表示一個閾值，表示數組容量和負載因子的乘積。但是我們發現，還沒分配數組的時候，其實是我們不小於指定容量的二次冪。
那么，數組什么時候才進行初始化呢？腦瓜子轉一下，應該就知道，是往里面存元素的時候。我們來看一看HashMap里面存儲元素的方法。
put方法
//聯系指定的鍵Key和值Value，如果在這之前map包含相同的key，返回舊key對應的value
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
巧妙的hash方法
其中調用了hash方法，對傳入的鍵key進行哈希計算，具體計算細節如下：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
我們着重了解一下，key不為null的情況下hash函數的實現，具體為啥要這樣設計，我們之后再總結：
- h存儲的是傳入key的哈希值，這個方法繼承於Object類，產生一個int值。
- 將上面這個老哈希值和無符號右移16位（將原高16位向低位移動，原高位全部以0填充）之后的新哈希值進行亦或運算，相同為0，不同為1。
有效地將高低位二進制特征混合，防止由高位的細微區別產生的頻繁哈希碰撞，具體可以看一下文末的參考鏈接。
JDK1.8的putVal方法
下面是一個及其關鍵的方法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;
//如果數組未初始化或者長度為0，則調用resize()初始化數組
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//根據hash值計算數組中的桶位，如果為null，則在該桶位上新建節點
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//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 {
//在節點后面插入新節點，桶中鏈表最多有8個節點，再加就變成了樹
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;
}
//判斷后面節點是否存在key相同的情況
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//e=p.next;p=e;這兩步完成遍歷
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;
//容量大於閾值，resize();
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
在沒了解resize方法之前，我們暫且將他定義成擴容和重哈希的重要方法，我們先就putVal方法進行一些總結：
- 我們看到，在沒有添加鍵值對的時候，數組並沒有初始化；在調用put方法之后，putVal中將會調用resize()真正對數組進行初始化，至於如何實現，我們待會分析resize。
- 我們還說過，HashMap主要利用了哈希函數對傳入的key值進行哈希運算，然后利用特殊的方法將求得的哈希值正確放入數組中的每個桶中。這個特殊的方法即:
p = tab[i = (n - 1) & hash]，n為數組的長度，它是2的冪次方，我們很容易能夠明白，通過(n-1)&hash產生的索引值必然落在0~n-1的范圍內，相當於i=hash%n,但是位運算的效率更高。這就是容量設置為2的冪次方數的另外原因。 (k = p.key) == key || (key != null && key.equals(k))),這一步兩邊分別表示key是否為null的情況。- 我們知道，
TREEIFY_THRESHOLD為8，是鏈表結構轉換為樹形結構的闕值，通過源碼我們可以知道，鏈表結構最多只能存儲8個節點，如果要存第9個，就需要調用treeifyBin(tab, hash);，轉換為樹。 - 通過遍歷的結構，我們可以發現，JDK1.8中，添加的操作會在鏈表的尾部執行。
- 遍歷之后，節點e不為null，說明確實找到了key相同的節點，這時替換value值，返回舊值。
++size > threshold),從這部分我們可以看出，除了初始化的時候是先resize再插入，其他的時候都是先插入，再判斷是否需要擴容。
樹化的時候除了TREEIFY_THRESHOLD為8之外，還需要滿足(n = tab.length) < MIN_TREEIFY_CAPACITY，滿足容量達到64，如果達不到的化，會選擇先resize擴容【補充於2021年1月23日】
JDK1.8的resize方法
那么接下來，終於輪到resize方法了，我們先看一下代碼的實現部分，哇這部分可是花了我好多的功夫，如果還有理解不正確的地方，還希望評論區批評指正：
final Node<K,V>[] resize() {
//oldTab存儲的是擴容前的數組
Node<K,V>[] oldTab = table;
//oldCap存儲的是擴容前的數組容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//oldThr存儲的是擴容前的閾值
int oldThr = threshold;
//newCap新數組容量，newThr新數組閾值
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
//如果老數組容量比數組最大容量還大，閾值變為Integer的最大值，返回老數組
threshold = Integer.MAX_VALUE;
return oldTab;
}
//新數組容量變為老數組容量的兩倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//新閾值變為兩倍需要上面的條件都成立（1、擴容兩倍之后的數組容量小於最大容量2、老容量大於等於16）
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
//使用帶有初始容量構造器，讓新容量變為通過initial capacity求得的threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//使用默認構造器，初始化容量為16
newCap = DEFAULT_INITIAL_CAPACITY;
//新容量變為16，新閾值變為0.75*16 = 12
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);
}
//將newThr賦值給threshold表示閾值
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) {
//創建臨時節點存儲老數組oldTab上的元素
Node<K,V> e;
//如果老數組上索引j的位置不為null
if ((e = oldTab[j]) != null) {
//將該位置置空
oldTab[j] = null;
//判斷下一位是否還有元素
if (e.next == null)
//下一位為空，則表明該桶位只有一個元素，搬移至新數組
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循環保證從到到尾遍歷鏈表
} while ((e = next) != null);
//如果尾節點不為空，就讓它的next指向空，鏈表完整
if (loTail != null) {
loTail.next = null;
//新數組的原索引位置指向鏈表頭節點
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
//新數組的原索引加老數組容量的索引位置指向鏈表頭節點
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
初始化部分
我們先談一談數組的初始化部分：
- 結合之前的putVal方法，我們知道當我們通過默認構造器創建HashMap，初始化為空的數組，threshold = 0。當第一次添加元素時進行擴容，此時數組容量為16，threshold為12。
- 當我們指定指定
initialCapacity的時候，threshold一開始表示的是大於等於initialCapacity最小的2的冪次方數，直到第一次添加元素時進行擴容，數組容量為threshold的值，而threshold此時為指定負載因子與數組容量的乘積。 - 若數組已經初始化，即數組容量>0時，再擴容，新容量變為原容量的兩倍，如果新容量小於最大容量，並且老容量>=16,此時threshold也變為原來的兩倍，否則threshold不變。
- 如果老數組的容量比最大容量還要大的話，閾值變為Integer的最大值，原數組不變。
數組搬移部分
我們重點談一談數組的搬移的基礎部分：
- 可以看到，通過for循環，通過j的改變，遍歷數組中的每個桶的位置。
- 如果桶位上只有一個節點，搬移操作很簡單：
newTab[e.hash & (newCap - 1)] = e;。 - 如果桶位上為樹形節點，就按樹形操作來：
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);。
最難的是，發生哈希碰撞時，數組的搬移是如何實現的呢？我們可以發現，源碼中對e.hash & oldCap的值是0還是1進行了分類判斷，為啥要這樣做呢？
- 我們知道，獲取數組中的桶的位置，可以通過數組容量-1&hash求得。
- 也就是說假如舊容量為16時，哈希值10和26和15進行與運算之后，都會保留二進制后四位的數，也就是都為10,其實這就是哈希碰撞產生的原因嘛。
我們首先必須明確，同樣的哈希值，擴容前后的區別只是在於被截取的那一位，就拿26而言（0001 1010），以16為容量時，它的有效索引位置為1010，而以32為容量時，它的有效索引則是11010，剛好差了10000，即oldCap，如下圖：
e.hash&oldCap為0，節點在新數組中的索引不變，newTab[j]。e.hash&oldCap為1，節點在新數組中的索引值 = 老數組容量+原索引值，newTab[j + oldCap]。
了解完這個，我們對其中哈希碰撞時節點搬移的代碼的分析開始！
關於其中針對e.hash & oldCap不同而定義的一對作用相同的節點，我們暫且將他們單獨拎出來，研究loHead和loTail，另外一對其實同理即可。
- 我們知道，單鏈表的組成由存儲的值和指向下一節點的指針next組成。
- 通過do……while循環從鏈表的頭節點向后，一直向尾節點進行遍歷，直到其為空。
- 建立臨時節點e指向老鏈表的頭節點，擁有相同的地址，其實就是擁有了與老鏈表相同的結構。
- 其實鏈表的遍歷的操作我們之前的文章已經分析過，這邊是通過下面的語句完成的。
//do……while循環
do{
next = e.next;
}while((e = next)!=null);
- 第一次進入循環時，loHead和loTail同時指向e，我在圖中用灰色表示loHead，用白色表示loTail。
- 后面每次進入循環，都會利用loTail節點向后移動，並將老鏈表的節點賦給新鏈表，一直串在頭節點之后。
- 直到遍歷至老鏈表的最后一個節點，退出循環。
- 如果新鏈表的尾節點不為null，將它的next指向null，此時一個完整的新鏈表就已經誕生。
loTail.next = null; - 將原數組的索引位置指向這個新鏈表的頭節點。
newTab[j] = loHead;
最后的最后，本文還有許多方面需要完善或者修改，之后會陸續將新體會上傳，還望評論區批評指正。
參考：
HashMap中的hash算法中的幾個疑問
HashMap中的hash函數
jdk1.8 HashMap工作原理和擴容機制(源碼解析)
Java 1.8中HashMap的resize()方法擴容部分的理解