看完你要是還搞不懂HashMap，我直接倒立喝水
前言
HashMap是基於哈希表的Map接口的非同步實現。此實現提供全部可選的映射操做，並容許使用null值和null鍵。此類不保證映射的順序，特別是它不保證該順序恆久不變。面試
HashMap的數據結構
在Java編程語言中，最基本的結構就是兩種，一個是數組，另一個是模擬指針（引用），全部的數據結構均可以用這兩個基本結構來構造的，HashMap也不例外。HashMap其實是一個「鏈表散列」的數據結構，即數組和鏈表的結合體。算法
文字描述永遠要配上圖才能更好的講解數據結構，HashMap的結構圖以下。 
編程
從上圖中能夠看出，HashMap底層就是一個數組結構，數組中的每一項又是一個鏈表或者紅黑樹。當新建一個HashMap的時候，就會初始化一個數組。數組
下面先經過大概看下HashMap的核心成員。數據結構
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
// 默認容量，默認爲16，必須是2的冪
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量，值是2^30
static final int MAXIMUM_CAPACITY = 1 << 30
// 裝載因子，默認的裝載因子是0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 解決衝突的數據結構由鏈表轉換成樹的閾值，默認爲8
static final int TREEIFY_THRESHOLD = 8;
// 解決衝突的數據結構由樹轉換成鏈表的閾值，默認爲6
static final int UNTREEIFY_THRESHOLD = 6;
/* 當桶中的bin被樹化時最小的hash表容量。
* 若是沒有達到這個閾值，即hash表容量小於MIN_TREEIFY_CAPACITY，當桶中bin的數量太多時會執行resize擴容操做。
* 這個MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
static class Node<K,V> implements Map.Entry<K,V> {
//...
}
// 存儲數據的數組
transient Node<K,V>[] table;
// 遍歷的容器
transient Set<Map.Entry<K,V>> entrySet;
// Map中KEY-VALUE的數量
transient int size;
/**
* 結構性變動的次數。
* 結構性變動是指map的元素數量的變化，好比rehash操做。
* 用於HashMap快速失敗操做，好比在遍歷時發生告終構性變動，就會拋出ConcurrentModificationException。
*/
transient int modCount;
// 下次resize的操做的size值。
int threshold;
// 負載因子，resize後容量的大小會增長現有size * loadFactor
final float loadFactor;
}
HashMap的初始化
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // 其餘值都是默認值
}
整理了一下2021年的Java工程師經典面試真題，共485頁大概850道含答案的面試題PDF，包含了Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、Redis、MySQL、Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、Linux 等幾乎全部技術棧，每一個技術棧都有很多於50道經典面試真題，不敢說刷完包你進大廠，但有針對性的刷讓你面對面試官的時候多幾分底氣仍是沒問題的。app
經過源碼能夠看出初始化時並無初始化數組table，那隻能在put操做時放入了，爲何要這樣作？估計是避免初始化了HashMap以後不使用反而佔用內存吧，哈哈哈。編程語言
HashMap的存儲操做
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
下面咱們詳細講一下HashMap是如何肯定數組索引的位置、進行put操做的詳細過程以及擴容機制(resize)ide
hash計算，肯定數組索引位置
無論增長、刪除、查找鍵值對，定位到哈希桶數組的位置都是很關鍵的第一步。前面說過HashMap的數據結構是數組和鏈表的結合，因此咱們固然但願這個HashMap裏面的元素位置儘可能分佈均勻些，儘可能使得每一個位置上的元素數量只有一個，那麼當咱們用hash算法求得這個位置的時候，立刻就能夠知道對應位置的元素就是咱們要的，不用遍歷鏈表，大大優化了查詢的效率。HashMap定位數組索引位置，直接決定了hash方法的離散性能。函數
看下源碼的實現:性能
static final int hash(Object key) { //jdk1.8
int h;
// h = key.hashCode() 爲第一步 取hashCode值
// h ^ (h >>> 16) 爲第二步 高位參與運算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
經過hashCode()的高16位異或低16位實現的：(h = k.hashCode()) ^ (h >>> 16)，主要是從速度、功效、質量來考慮的，這麼作能夠在數組table的length比較小的時候，也能保證考慮到高低Bit都參與到Hash的計算中，同時不會有太大的開銷。
你們都知道上面代碼里的key.hashCode()函數調用的是key鍵值類型自帶的哈希函數，返回int型散列值。理論上散列值是一個int型，若是直接拿散列值做爲下標訪問HashMap主數組的話，考慮到2進制32位帶符號的int表值範圍從‑2147483648到2147483648。先後加起來大概40億的映射空間。只要哈希函數映射得比較均勻鬆散，通常應用是很難出現碰撞的。但問題是一個40億長度的數組，內存是放不下的。你想，HashMap擴容以前的數組初始大小才16。因此這個散列值是不能直接拿來用的。用以前還要先作對數組的長度取模運算，獲得的餘數才能用來訪問數組下標。源碼中模運算是在這個indexFor( )函數里完成。
bucketIndex = indexFor(hash, table.length);
//indexFor的代碼也很簡單，就是把散列值和數組長度作一個"與"操做，
static int indexFor(int h, int length) {
return h & (length-1);
}
順便說一下，這也正好解釋了爲什麼HashMap的數組長度要取2的整次冪。由於這樣（數組長度‑1）正好至關於一個「低位掩碼」。「與」操做的結果就是散列值的高位所有歸零，只保留低位值，用來作數組下標訪問。以初始長度16爲例，16‑1=15。2進製表示是000000000000000000001111。和某散列值作「與」操做以下，結果就是截取了最低的四位值。
10100101 11000100 00100101 & 00000000 00000000 00001111 ---------------------------------- 00000000 00000000 00000101 //高位所有歸零，只保留末四位
但這時候問題就來了，這樣就算個人散列值分佈再鬆散，要是隻取最後幾位的話，碰撞也會很嚴重。更要命的是若是散列自己作得不好，分佈上成等差數列的漏洞，剛好使最後幾個低位呈現規律性重複，就無比蛋疼。這時候「擾動函數」的價值就出來了，說到這你們應該都明白了，看下圖。
hash計算過程
右位移16位，正好是32bit的一半，本身的高半區和低半區作異或，就是爲了混合原始哈希碼的高位和低位，以此來加大低位的隨機性。並且混合後的低位摻雜了高位的部分特徵，這樣高位的信息也被變相保留下來。
putVal方法
HashMap的put方法執行過程能夠經過下圖來理解，本身有興趣能夠去對比源碼更清楚地研究學習。
源碼以及解釋以下:
// 真正的put操做
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 若是table沒有初始化，或者初始化的大小爲0，進行resize操做
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 若是hash值對應的桶內沒有數據，直接生成結點而且把結點放入桶中
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 若是hash值對應的桶內有數據解決衝突，再放入桶中
else {
Node<K,V> e; K k;
//判斷put的元素和已經存在的元素是相同(hash一致，而且equals返回true)
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// put的元素和已經存在的元素是不相同(hash一致，而且equals返回true)
// 若是桶內元素的類型是TreeNode，也就是解決hash解決衝突用的樹型結構，把元素放入樹種
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 桶內元素的類型不是TreeNode，而是鏈表時，把數據放入鏈表的最後一個元素上
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 若是鏈表的長度大於轉換爲樹的閾值(TREEIFY_THRESHOLD)，將存儲元素的數據結構變動爲樹
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;
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;
// 若是K-V數量大於閾值，進行resize操做
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
擴容機制
HashMap的擴容機制用的很巧妙，以最小的性能來完成擴容。擴容後的容量就變成了變成了以前容量的2倍，初始容量爲16，因此通過rehash以後，元素的位置要麼是在原位置，要麼是在原位置再向高下標移動上次容量次數的位置，也就是說若是上次容量是16，下次擴容後容量變成了16+16，若是一個元素在下標爲7的位置，下次擴容時，要不還在7的位置，要不在7+16的位置。
咱們下面來解釋一下Java8的擴容機制是怎麼作到的？n爲table的長度，圖（a）表示擴容前的key1和key2兩種key肯定索引位置的示例，圖（b）表示擴容後key1和key2兩種key肯定索引位置的示例，其中hash1是key1對應的哈希與高位運算結果。
元素在從新計算hash以後，由於n變爲2倍，那麼n-1的mask範圍在高位多1bit(紅色)，所以新的index就會發生這樣的變化：
所以，咱們在擴充HashMap的時候，不須要像JDK1.7的實現那樣從新計算hash，只須要看看原來的hash值新增的那個bit是1仍是0就行了，是0的話索引沒變，是1的話索引變成「原索引+oldCap」，能夠看看下圖爲16擴充爲32的resize示意圖：
而hash值的高位是否爲1，只須要和擴容後的長度作與操做就能夠了，由於擴容後的長度爲2的次冪，因此高位必爲1，低位必爲0，如10000這種形式，源碼中有e.hash & oldCap來作到這個邏輯。
這個設計確實很是的巧妙，既省去了從新計算hash值的時間，並且同時，因爲新增的1bit是0仍是1能夠認爲是隨機的，所以resize的過程，均勻的把以前的衝突的節點分散到新的bucket了。這一塊就是JDK1.8新增的優化點。有一點注意區別，JDK1.7中rehash的時候，舊鏈表遷移新鏈表的時候，若是在新表的數組索引位置相同，則鏈表元素會倒置，可是從上圖能夠看出，JDK1.8不會倒置。下面是JDK1.8的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;
}
// 沒超過最大值，就擴充爲原來的2倍
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);
}
// 計算新的resize上限
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;
if (oldTab != null) {
// 把每一個bucket都移動到新的buckets中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//若是位置上沒有元素，直接爲null
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//若是隻有一個元素，新的hash計算後放入新的數組中
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;
//hash碰撞後高位爲0，放入低Hash值的鏈表中
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//hash碰撞後高位爲1，放入高Hash值的鏈表中
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 低hash值的鏈表放入數組的原始位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 高hash值的鏈表放入數組的原始位置 + 原始容量
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
- 1. 看完你要是還搞不懂HashMap，我直接倒立喝水
- 2. 我就不信看完這篇你還搞不懂信息熵
- 3. 看完這篇你還不懂Spring Boot與日誌，我倒立洗頭！
- 4. 看完這篇還搞不懂webpack，求你打我
- 5. 若是你還搞不懂HTTP報文
- 6. 還看不懂JDK7 HashMap環的產生原理你來打我
- 7. 看完還不懂HTTPS我直播吃翔
- 8. 一文徹底搞懂流水線的調度問題，看完不懂打我
- 9. 大寫的服，看完這篇你還不懂RocketMQ算我輸
- 10. 還不懂什麼是B+樹？看完這篇包你明白
- 更多相關文章...
- • RDF 主要 元素 - RDF 教程
- • TCP三次握手建立連接的過程 - TCP/IP教程
- • 再有人問你分佈式事務，把這篇扔給他
- • SpringBoot中properties文件不能自動提示解決方法
-
每一个你不满意的现在，都有一个你没有努力的曾经。