本文按以下順序敘述:
把源碼啃下來有一種很爽的感覺, 相信你讀完后也能體會到~ 如發現有誤, 歡迎指出.
在開始之前, 先通過圖例對HashMap建立感性認識
- 如果不清楚哈希表是一種什么樣的數據結構的話, 可以先看書了解一下, 如果覺得看書麻煩, 推薦看一下浙大數據公開課中的[第十一講 散列查找](https://www.icourse163.org/course/zju0901-93001?from=study), 了解了這種數據結構后理解HashMap就沒有問題了.
- HashMap由一個數組組成, 對於每個鍵值對, 會通過對鍵進行哈希計算, 直接得出該鍵值對存儲的位置, 保證了存取鍵值的操作擁有極其優良的時間性能.
- 當兩個鍵值對存儲的位置發生沖突時, 會通過鏈表把鍵值對在對應的位置上用鏈表連起來. 如果鏈太長的話, (在JDK1.8后)會把鏈表轉換為存取效率更高的紅黑樹, 以保證HashMap的整體存取效率.
- HashMap中有專門記錄容量的參數, 如果容量增大到一定的值會進行擴容, 使得HashMap散列更均勻, 整體存取效率更高.
下面是基於官方文檔的粗糙翻譯
- HashMap和Hashtable是相似的, 只不過它是線程不安全的, 並且允許null值. 它不能保證鍵值對的有序性, 鍵值對的順序甚至會在使用的過程中發生變化 (擴容等操作會重新進行哈希操作, 鍵值對的位置發生變化). - 在哈希函數能散列均勻的前提下, 它能保證put和get兩個基本操作有穩定的時間性能. - 遍歷HashMap所需要的時間和它的容量是成正比的, 如果迭代性能很重要, 請不要把初始容量設置得過高(或把負載因子設置得過小, 過小則會經常進行重新哈希的操作). - 兩個參數影響着HashMap的性能: 初始容量和負載因子. 這里的初始容量指創建Hash表時所開辟的內存空間. 負載因子是一個小數, 用於判斷HashMap是否已經滿了. 當map中的元素超過了負載因子和當前容量的乘積后, HashMap會進行擴容, 大概擴為原來大小的兩倍. (比如說負載因子是0.75, 初始容量是100, 當實際容量達到`0.75*100=75`時, HashMap就會進行擴容) - 一般來說, 默認負載因子(0.75)在時間和空間成本之間提供了很好的平衡。設置一個更大的負載因子值雖然節省了空間，但是增加了查找的時間成本(查找時間的增加會影響HashMap的大部分操作，包括get和set)，所以在設置HashMap的初始容量的時候要考慮map中預期的裝填元素數量和負載因子的大小，以最大限度減少擴容的次數. - 要注意的是HashMap是線程不安全的, 官方建議從外部實現對HashMap的同步操作, 官方給出的建議是 `Map m = Collections.synchronizedMap(new HashMap(...));` 當然也可以用`ConcurrentHashMap`替代. - 使用iterator迭代器遍歷HashMap時有一個fail-fast快速容錯機制. 在使用迭代器遍歷容器的過程中, 任何對HashMap結構進行修改的都會導致`ConcurrentModificationException`並發修改異常. 如果不想這個異常出現, 但又想刪除某個元素, 就要調用iterator迭代器自身的`remove`方法. 如果沒有這個機制, 在迭代的過程中增刪元素可能會導致HashMap結構的變更(比如擴容), 繼續遍歷的時候便會出錯, 這一機制把這種風險扼殺在搖籃中.
源碼分析
1. HashMap的創建
在創建HashMap之前, 先看看它的幾個基本屬性
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16, HashMap的默認初始容量
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量, 如果在創建HashMap時顯示指定HashMap的大小, 則不能超過這個值, 否則會默認使用這個值
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默認負載因子
static final int MIN_TREEIFY_CAPACITY = 64;//當HashMap的容量大於這個值, 一個位置沖突過多時才能轉為紅黑樹, 否則解決沖突過多的方式是擴容
static final int TREEIFY_THRESHOLD = 8;//沖突時元素會用鏈表連起來, 當鏈表的長度達到了這個值, 就會轉換為紅黑樹
static final int UNTREEIFY_THRESHOLD = 6;//當紅黑樹的結點數量少於這個值的時候, 會轉換回鏈表.
/**
* The next size value at which to resize (capacity * load factor).
*/
int threshold; //當前容量與負載因子的乘積, 用於判斷是否要擴容.
- HashMap一共有4個構造器. 這里只給出了無參構造, 如果清楚HashMap的使用環境, 可以使用其他有參構造設定初始容量和負載因子.
- 如果使用無參構造創建HashMap, 會把負載因子設置為0.75, 其他額外的屬性都按照默認值進行初始化.
/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* The load factor for the hash table.
*
* @serial
*/
final float loadFactor;
//無參構造
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
- 至此, HashMap創建完畢. 在創建HashMap的時候, 並沒有為數組分配空間, 那么這些必要步驟什么時候做呢? 請繼續看...
2. HashMap的使用
- HashMap的使用, 無非就是鍵值對的存儲了, 先看存的代碼.
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
- 我們發現在調用
put()方法的時候其實調用的是putVal()方法. putVal()是個重要的方法, 通過方法, 我們能對HashMap有個深入的理解.
/**
* Implements Map.put and related methods
*
* @param hash hash for key key的hash code經過再次計算后得出hash值.
* @param key the key key值
* @param value the value to put value值
* @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;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
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);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
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;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- 分析如下:
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
- 首先判斷table是否為空, 如果為空的話會調用
resize()方法, 完成對HashMap的初始化, 為HashMap中的數組分配內存空間. resize()有兩個作用: 1. 對HashMap進行初始化; 2. 進行兩倍的擴容.
這里插入resize()方法的分析, 如需跳過, 點擊這里
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else 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);
}
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 = newTab; //如果是初始化HashMap, 到這里就夠了, 會跳過if判斷並返回
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
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 ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
- 首先判斷HashMap容量是否超過了默認的最大值, 如果是就不會進行擴容, 並返回原表.
- 然后確定新表的大小
newCap, 確定新表的threshold值(用於判斷是否要擴容)newThr. - 確定好這兩個值后, 如果是初始化HashMap, 由於原表為空
oldTab == null,resize()函數也就結束了, 返回初始好的新表. - 如果
oldTab != null, 也就說這次調用resize()是進行擴容, 那么在創建好新表后, 就要把原來的數據重新計算並搬運到新表中. - 搬運數據的過程還是蠻有意思的, 分析如下:
在HashMap中計算元素存放位置的代碼是 (n - 1) & hash
其中n是哈希表數組的長度, 這行代碼保證了元素能落在數組的下標范圍內
現在我們要進行擴容, 假設hash值為101010
初始容量 n = 16 , 計算地址: (n - 1) & hash = 1111 & 101010 = 001010
擴后容量 n = 32 , 計算地址: (n - 1) & hash = 11111 & 101010 = 001010
我們發現hash值為101010的時候計算出來的地址是一樣的, 那么這個元素就不用挪位了.
再舉例:
假設當前元素hash值為1010101
初始容量 n = 16 , 計算地址: (n - 1) & hash = 1111 & 1010101 = 0000101
擴后容量 n = 32 , 計算地址: (n - 1) & hash = 11111 & 1010101 = 0010101
我們發現這時兩個地址不相等, 新地址為: 原地址 + 原長度 (0000101 + 16) = 0010101
這是一個精心的設計, 是這樣的:
原來計算地址時 : (n - 1) = 1111 一共有4位
擴容后計算地址 : (n - 1) = 11111 多了一位, 多在了第五位
回頭看hash值
第一個hash值: 101010. 第五位為0
第二個hash值: 1010101. 第五位為1
設計的原理就是: 在計算地址的時候, (n - 1)會比原來多了一位, 假設多的是第n位.
如果hash值的第n位為0那么元素就不用移動, 如果為1, 就要移動到新位置.
所以從嚴謹的角度看, 擴容的時候不是對每個元素重新計算哈希,
而是把每個位置上的元素分成兩類調整位置.
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) {//判斷第n位是否為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 ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;//在原位放好不用動的
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;//移動的位置: 原位置 + 原長度
}
}
下面繼續是`putVal()`的分析
```java if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); ``` - 拿到數組后, 根據hash值計算插入地址`tab[i = (n - 1) & hash]`, 如果該地址中沒有元素, 就直接插入. 插入完判斷需不需要擴容`if (++size > threshold)`, 如果需要就擴容, 不需要的話本次`put()`方法就結束了, 返回null. - 如果插入的地方已經有元素了, 也就是發生了沖突. ```java if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; ``` - 首先會判斷Key是否相同, 如果相同, 就就行判斷是否能替換值, 能就替換 ``` if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null)//在日常使用中, 基本新value都會替換舊value e.value = value; afterNodeAccess(e); return oldValue; } ``` - 如果不相同, 就要尋找插入的位置, 如果當前桶里裝的是鏈表, 則遍歷鏈表(遍歷的過程中仍會判斷是否有相同的key), 如果裝的是紅黑樹, 則按照紅黑樹的策略尋找插入點(期間仍會判斷是否有相同的key). ``` else if (p instanceof TreeNode) e = ((TreeNode- 補充: 在桶里裝鏈表的情況下, 插入元素后會判斷鏈表的長度有沒有達到轉換為紅黑樹的要求. 如果達到了就調用`treeifyBin()`方法.
- 但注意: 並不是調用了`treeifyBin()`就會把桶中的結構轉換為紅黑樹. 回想一下文章開頭提及的基本參數, 有一個參數是`MIN_TREEIFY_CAPACITY`, 如果當前數組長度還沒有達到這個參數的值, 是不會轉換結構的, 會進行擴容`resize()`.
---
> 結束
- 看到這里, HashMap在你的面前應該是沒有什么秘密了.
- 曾經看過一個有關HashMap並發造成死循環的問題. 左耳朵耗子的博客中有詳細的描述, [點此跳轉](https://coolshell.cn/articles/9606.html)
- 但是這個問題在JDK1.8中已經處理了. 造成死循環的原因是擴容時重新插入鏈表時是倒序插入的, JDK1.8中用了兩條鏈表分別操作, 保證了鏈表插入到Map時還是按順序插入的, 避免了死循環.