HashMap系列之重要方法原始碼詳解
阿新 • • 發佈：2020-07-11
HashMap 中重要的構造方法：
1、構造一個空的 HashMap，預設初始容量（16）和預設負載因子（0.75）。
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // 將預設的載入因子0.75賦值給loadFactor，並沒有建立陣列
}
2、 構造一個具有指定的初始容量和預設負載因子（0.75）HashMap。
// 指定“容量大小”的建構函式 public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
3、 構造一個具有指定的初始容量和負載因子的HashMap。我們來分析一下。
/* 指定“容量大小”和“載入因子”的建構函式 initialCapacity: 指定的容量 loadFactor:指定的載入因子 */ public HashMap(int initialCapacity, float loadFactor) { //判斷初始化容量initialCapacity是否小於0 if (initialCapacity < 0) //如果小於0，則丟擲非法的引數異常IllegalArgumentException throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); //判斷初始化容量initialCapacity是否大於集合的最大容量MAXIMUM_CAPACITY-》2的30次冪 if (initialCapacity > MAXIMUM_CAPACITY) //如果超過MAXIMUM_CAPACITY，會將MAXIMUM_CAPACITY賦值給initialCapacity initialCapacity = MAXIMUM_CAPACITY; //判斷負載因子loadFactor是否小於等於0或者是否是一個非數值 if (loadFactor <= 0 || Float.isNaN(loadFactor)) //如果滿足上述其中之一，則丟擲非法的引數異常IllegalArgumentException throw new IllegalArgumentException("Illegal load factor: " + loadFactor); //將指定的載入因子賦值給HashMap成員變數的負載因子loadFactor this.loadFactor = loadFactor; /* tableSizeFor(initialCapacity) 判斷指定的初始化容量是否是2的n次冪，如果不是那麼會變為比指定初始化容量大的最小的2的n次冪。 這點上述已經講解過。但是注意，在tableSizeFor方法體內部將計算後的資料返回給呼叫這裡了，並且直接賦值給threshold邊界值了。 有些人會覺得這裡是一個bug,應該這樣書寫：this.threshold = tableSizeFor(initialCapacity) * this.loadFactor; 這樣才符合threshold的意思（當HashMap的size到達threshold這個閾值時會擴容）。但是，請注意，在jdk8以後的構造方法中， 並沒有對table這個成員變數進行初始化，table的初始化被推遲到了put方法中，在put方法中會對threshold重新計算，put方法 的具體實現我們下面會進行講解 */ this.threshold = tableSizeFor(initialCapacity); } //最後呼叫了tableSizeFor，來看一下方法實現： /** * Returns a power of two size for the given target capacity. 返回比指定初始化容量大的最小的2的n次冪 */ 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; }
增加方法
put方法是比較複雜的，實現步驟大致如下：
-
先通過hash值計算出key對映到哪個桶；
-
如果桶上沒有碰撞衝突，則直接插入；
-
如果出現碰撞衝突了，則需要處理衝突;
-
如果該桶使用紅黑樹處理衝突，則呼叫紅黑樹的方法插入資料；
-
採用傳統的鏈式方法插入，如果鏈的長度達到臨界值，則把鏈轉變為紅黑樹；
-
-
如果桶中存在重複的鍵，則為該鍵替換新值value；
-
如果size大於閾值threshold，則進行擴容。
-
具體的方法如下：
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
說明：
-
HashMap只提供了put用於新增元素，putVal方法只是給put方法呼叫的一個方法，並沒有提供給使用者使用。 重點看putVal方法。
-
可以看到在putVal()方法中key在這裡執行了一下hash()方法，來看一下Hash方法是如何實現的。
static final int hash(Object key) { int h; /* 1）如果key等於null：可以看到當key等於null的時候也是有雜湊值的，返回的是0. 2）如果key不等於null：首先計算出key的hashCode賦值給h,然後與h無符號右移16位後的二進位制進行按位異或得到最後的hash值 */ return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }從上面程式碼可以看到**HashMap是支援Key為空的**，而HashTable是直接用Key來獲取HashCode所以key為空會拋異常。
putVal()方法原始碼詳解
public V put(K key, V value)
{
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
/*
1）transient Node<K,V>[] table; 表示儲存Map集合中元素的陣列。
2）(tab = table) == null 表示將空的table賦值給tab,然後判斷tab是否等於null，第一次肯定是null
3）(n = tab.length) == 0 表示將陣列的長度0賦值給n,然後判斷n是否等於0，n等於0
由於if判斷使用雙或，滿足一個即可，則執行程式碼 n = (tab = resize()).length; 進行陣列初始化。
並將初始化好的陣列長度賦值給n.
4）執行完n = (tab = resize()).length，陣列tab每個空間都是null
*/
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/*
1）i = (n - 1) & hash 表示計算陣列的索引賦值給i，即確定元素存放在哪個桶中
2）p = tab[i = (n - 1) & hash]表示獲取計算出的位置的資料賦值給節點p
3) (p = tab[i = (n - 1) & hash]) == null 判斷節點位置是否等於null，如果為null，則執行程式碼：
tab[i] = newNode(hash, key, value, null);根據鍵值對建立新的節點放入該位置的桶中
小結：如果當前桶沒有雜湊碰撞衝突，則直接把鍵值對插入空間位置
*/
if ((p = tab[i = (n - 1) & hash]) == null)
//建立一個新的節點存入到桶中
tab[i] = newNode(hash, key, value, null);
else {
// 執行else說明tab[i]不等於null，表示這個位置已經有值了。
Node<K,V> e; K k;
/*
比較桶中第一個元素(陣列中的結點)的hash值和key是否相等
1）p.hash == hash ：p.hash表示原來存在資料的hash值 hash表示後新增資料的hash值 比較兩個hash值是否相等
說明：p表示tab[i]，即 newNode(hash, key, value, null)方法返回的Node物件。
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next)
{
return new Node<>(hash, key, value, next);
}
而在Node類中具有成員變數hash用來記錄著之前資料的hash值的
2）(k = p.key) == key ：p.key獲取原來資料的key賦值給k key 表示後新增資料的key 比較兩個key的地址值是否相等
3）key != null && key.equals(k)：能夠執行到這裡說明兩個key的地址值不相等，那麼先判斷後新增的key是否等於null，
如果不等於null再呼叫equals方法判斷兩個key的內容是否相等
*/
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
/*
說明：兩個元素雜湊值相等，並且key的值也相等
將舊的元素整體物件賦值給e，用e來記錄
*/
e = p;
// hash值不相等或者key不相等；判斷p是否為紅黑樹結點
else if (p instanceof TreeNode)
// 放入樹中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 說明是連結串列節點
else {
/*
1)如果是連結串列的話需要遍歷到最後節點然後插入
2)採用迴圈遍歷的方式，判斷連結串列中是否有重複的key
*/
for (int binCount = 0; ; ++binCount) {
/*
1)e = p.next 獲取p的下一個元素賦值給e
2)(e = p.next) == null 判斷p.next是否等於null，等於null，說明p沒有下一個元素，
那麼此時到達了連結串列的尾部，還沒有找到重複的key,則說明HashMap沒有包含該鍵將該鍵值對插入連結串列中
*/
if ((e = p.next) == null) {
/*
1）建立一個新的節點插入到尾部
p.next = newNode(hash, key, value, null);
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next)
{
return new Node<>(hash, key, value, next);
}
注意第四個引數next是null，因為當前元素插入到連結串列末尾了，那麼下一個節點肯定是 null
2）這種新增方式也滿足連結串列資料結構的特點，每次向後新增新的元素
*/
p.next = newNode(hash, key, value, null);
/*
1)節點新增完成之後判斷此時節點個數是否大於TREEIFY_THRESHOLD臨界值8，如果大於則將連結串列轉換為紅黑樹
2）int binCount = 0 ：表示for迴圈的初始化值。從0開始計數。記錄著遍歷節點的個數。值是0表示第一個節點，
1表示第二個節點。。。。7表示第八個節點，加上陣列中的的一個元素，元素個數是9
TREEIFY_THRESHOLD - 1 --》8 - 1 ---》7，如果binCount的值是7(加上陣列中的的一個元素，元素個數是9)
TREEIFY_THRESHOLD - 1也是7，此時轉換紅黑樹
*/
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//轉換為紅黑樹
treeifyBin(tab, hash);
// 跳出迴圈
break;
}
/*
執行到這裡說明e = p.next 不是null，不是最後一個元素。繼續判斷連結串列中結點的key值與插入的元素的key值是否相等
*/
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// 相等，跳出迴圈
/*
要新增的元素和連結串列中的存在的元素的key相等了，則跳出for迴圈。不用再繼續比較了
直接執行下面的if語句去替換去 if (e != null)
*/
break;
/*
說明新新增的元素和當前節點不相等，繼續查詢下一個節點。
用於遍歷桶中的連結串列，與前面的e = p.next組合，可以遍歷連結串列
*/
p = e;
}
}
/*
表示在桶中找到key值、hash值與插入元素相等的結點
也就是說通過上面的操作找到了重複的鍵，所以這裡就是把該鍵的值變為新的值，並返回舊值
這裡完成了put方法的修改功能
*/
if (e != null) {
// 記錄e的value
V oldValue = e.value;
// onlyIfAbsent為false或者舊值為null
if (!onlyIfAbsent || oldValue == null)
//用新值替換舊值
//e.value 表示舊值 value表示新值
e.value = value;
// 訪問後回撥
afterNodeAccess(e);
// 返回舊值
return oldValue;
}
}
//修改記錄次數
++modCount;
// 判斷實際大小是否大於threshold閾值，如果超過則擴容
if (++size > threshold)
resize();
// 插入後回撥
afterNodeInsertion(evict);
return null;
}
連結串列轉換為紅黑樹的treeifyBin方法
/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
替換指定雜湊表的索引處桶中的所有連結節點，除非表太小，否則將修改大小。
Node<K,V>[] tab = tab 陣列名
int hash = hash表示雜湊值
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
/*
如果當前陣列為空或者陣列的長度小於進行樹形化的閾值(MIN_TREEIFY_CAPACITY = 64),
就去擴容。而不是將節點變為紅黑樹。
目的：如果陣列很小，那麼轉換紅黑樹，然後遍歷效率要低一些。這時進行擴容，那麼重新計算雜湊值
，連結串列長度有可能就變短了，資料會放到陣列中，這樣相對來說效率高一些。
*/
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//擴容方法
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
/*
1）執行到這裡說明雜湊表中的陣列長度大於閾值64，開始進行樹形化
2）e = tab[index = (n - 1) & hash]表示將陣列中的元素取出賦值給e,e是雜湊表中指定位置桶裡的連結串列節點，從第一個開始
*/
//hd：紅黑樹的頭結點 tl :紅黑樹的尾結點
TreeNode<K,V> hd = null, tl = null;
do {
//新建立一個樹的節點，內容和當前連結串列節點e一致
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
//將新創鍵的p節點賦值給紅黑樹的頭結點
hd = p;
else {
/*
p.prev = tl：將上一個節點p賦值給現在的p的前一個節點
tl.next = p;將現在節點p作為樹的尾結點的下一個節點
*/
p.prev = tl;
tl.next = p;
}
tl = p;
/*
e = e.next 將當前節點的下一個節點賦值給e,如果下一個節點不等於null
則回到上面繼續取出連結串列中節點轉換為紅黑樹
*/
} while ((e = e.next) != null);
/*
讓桶中的第一個元素即陣列中的元素指向新建的紅黑樹的節點，以後這個桶裡的元素就是紅黑樹
而不是連結串列資料結構了
*/
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
小結：上述操作一共做了如下幾件事：
- 根據雜湊表中元素個數確定是擴容還是樹形化；
- 如果是樹形化遍歷桶中的元素，建立相同個數的樹形節點，複製內容，建立起聯絡；
- 最後讓桶中的第一個元素指向新建立的樹根節點，替換桶的連結串列內容為樹形化內容。
擴容機制
-
什麼時候才需要擴容
當HashMap中的元素個數超過陣列大小(陣列長度)*loadFactor(負載因子)時，就會進行陣列擴容，loadFactor的預設值(DEFAULT_LOAD_FACTOR)是0.75，
這是一個折中的取值。也就是說，預設情況下，陣列大小為16，那麼當HashMap中的元素個數超過16×0.75=12(這個值就是閾值或者邊界值threshold值)的
時候，就把陣列的大小擴充套件為2×16=32，即擴大一倍，然後重新計算每個元素在陣列中的位置，而這是一個非常耗效能的操作，所以如果我們已經預知
HashMap中元素的個數，那麼預知元素的個數能夠有效的提高HashMap的效能。注意：當HashMap中的其中一個連結串列的物件個數如果達到了8個，此時如果陣列長度沒有達到64，那麼HashMap會先擴容解決，如果已經達到了64，
那麼這個連結串列會變成紅黑樹，節點型別由Node變成TreeNode型別。當然，如果對映關係被移除後，下次執行resize方法時判斷樹的節點
個數低於6，也會再把樹轉換為連結串列。 -
HashMap的擴容是什麼
進行擴容，會伴隨著一次重新hash分配，並且會遍歷hash表中所有的元素，是非常耗時的。在編寫程式中，要儘量
避免resize。 HashMap在進行擴容時，使用的rehash方式非常巧妙，因為每次擴容都是翻倍，與原來計算的 (n-1)&hash的結果相比，
只是多了一個bit位，所以節點要麼就在原來的位置，要麼就被分配到"原位置+舊容量"這個位置。
怎麼理解呢？例如我們從16擴充套件為32時，具體的變化如下所示：
&（按位與運算）：運算規則：相同的二進位制數位上，都是1的時候，結果為1，否則為零。
hash1:1111 1111 1111 1111 0000 1111 0000 0101
hash2:1111 1111 1111 1111 0000 1111 0001 0101
因此元素在重新計算hash之後，因為n變為2倍，那麼n-1的標記範圍在高位多1bit(紅色)，因此新的index就會發生這樣的變化：
說明：5是假設計算出來的原來的索引。這樣就驗證了上述所描述的：擴容之後所以節點要麼就在原來的位置，要麼就被分配到"原位置+舊容量"這個位置。
因此，我們在擴充HashMap的時候，不需要重新計算hash，只需要看看原來的hash值新增的那個bit是1還是0就可以了，是0的話索引沒變，
是1的話索引變成“原索引+oldCap(原位置+舊容量)”。可以看看下圖為16擴充為32的resize示意圖：
正是因為這樣巧妙的rehash方式，既省去了重新計算hash值的時間，而且同時，由於新增的1bit是0還是1可以認為是隨機的，
在resize的過程中保證了rehash之後每個桶上的節點數一定小於等於原來桶上的節點數，保證了rehash之後不會出現更嚴重
的hash衝突，均勻的把之前的衝突的節點分散到新的桶中了。
原始碼resize方法詳解
final Node<K,V>[] resize() {
//得到當前陣列
Node<K,V>[] oldTab = table;
//如果當前陣列等於null長度返回0，否則返回當前陣列的長度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//當前閾值點 預設是12(16*0.75)
int oldThr = threshold;
int newCap, newThr = 0;
//如果老的陣列長度大於0
//開始計算擴容後的大小
if (oldCap > 0) {
// 超過最大值就不再擴充了，就只好隨你碰撞去吧
if (oldCap >= MAXIMUM_CAPACITY) {
//修改閾值為int的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
/*
沒超過最大值，就擴充為原來的2倍
1)(newCap = oldCap << 1) < MAXIMUM_CAPACITY 擴大到2倍之後容量要小於最大容量
2）oldCap >= DEFAULT_INITIAL_CAPACITY 原陣列長度大於等於陣列初始化長度16
*/
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//閾值擴大一倍
newThr = oldThr << 1; // double threshold
}
//老閾值點大於0 直接賦值
else if (oldThr > 0) // 老閾值賦值給新的陣列長度
newCap = oldThr;
else {// 直接使用預設值
newCap = DEFAULT_INITIAL_CAPACITY;//16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 計算新的resize最大上限
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//新的閾值 預設原來是12 乘以2之後變為24
threshold = newThr;
//建立新的雜湊表
@SuppressWarnings({"rawtypes","unchecked"})
//newCap是新的陣列長度--》32
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//判斷舊陣列是否等於空
if (oldTab != null) {
// 把每個bucket都移動到新的buckets中
//遍歷舊的雜湊表的每個桶，重新計算桶裡元素的新位置
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
//原來的資料賦值為null 便於GC回收
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 { // 採用連結串列處理衝突
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//通過上述講解的原理來計算節點的新位置
do {
// 原索引
next = e.next;
//這裡來判斷如果等於true e這個節點在resize之後不需要移動位置
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 原索引+oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 原索引放到bucket裡
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 原索引+oldCap放到bucket裡
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}