JDK1.8源碼閱讀HashMap.class
建議：
- 學習關鍵是效率，先上B站找hash算法和紅黑樹算法的視頻初步瞭解，事半功倍
- 再配合hashtable.class源碼（更容易理解）對比閱讀，因爲hashmap是hashtable的升級版。
0、hashmap特性：非線程安全，允許一個key爲null，value不做限制。
1、瞭解hashmap底層儲存的數據結構（數組+鏈表）
2、hashmap數據增刪的處理邏輯，其算法邏輯本質是hash函數和紅黑樹（平衡二叉樹）
3、爲什麼會需要hashmap，其它的集合不香嗎（域其它集合的區別）
4、hashmap在JDK歷史版本中的改動原因
HashMap數據結構
- Hashmap的底層數據結構是由數組
Node<K, V>[]+鏈表Node(int hash, K key, V value, Node<K, V> next)組成的
transient Node<K, V>[] table;
static class Node<K, V> implements Map.Entry<K, V> {
final int hash;// hash存儲key的hashCode
final K key;
V 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;
}
hashmap數據增刪的處理邏輯
如何增加節點
- 添加數據有兩種情況，一是與原表中存在數據位置相同，相當於修改；二是原表中沒有，相當於覆蓋空位置。
/**
* 將指定參數key和指定參數value插入map中，如果key已經存在，那就替換key對應的value
* put(K key, V value)可以分爲三個步驟：
* 1.通過hash(Object key)方法計算key的哈希值。
* 2.通過putVal(hash(key), key, value, false, true)方法實現功能。
* 3.返回putVal方法返回的結果。
* @return 如果value被替換，則返回舊的value，否則返回null。當然，可能key對應的value就是null
*/
public V put(K key, V value) {
// 倒數第二個參數false：表示允許舊值替換
// 最後一個參數true：表示HashMap不處於創建模式
return putVal(hash(key), key, value, false, true);
}
/**
* Map.put和其他相關方法的實現需要的方法
* putVal方法可以分爲下面的幾個步驟:
* 1.如果哈希表爲空，調用resize()創建一個哈希表。
* 2.如果指定參數hash在表中沒有對應的桶，即爲沒有碰撞，直接將鍵值對插入到哈希表中即可。
* 3.如果有碰撞，遍歷桶，找到key映射的節點
* 3.1桶中的第一個節點就匹配了，將桶中的第一個節點記錄起來。
* 3.2如果桶中的第一個節點沒有匹配，且桶中結構爲紅黑樹，則調用紅黑樹對應的方法插入鍵值對。
* 3.3如果不是紅黑樹，那麼就肯定是鏈表。遍歷鏈表，如果找到了key映射的節點，就記錄這個節點，退出循環。如果沒有找到，在鏈表尾部插入節點。插入後，如果鏈的長度大於等於TREEIFY_THRESHOLD這個臨界值，則使用treeifyBin方法把鏈表轉爲紅黑樹。
* 4.如果找到了key映射的節點，且節點不爲null
* 4.1記錄節點的vlaue。
* 4.2如果參數onlyIfAbsent爲false，或者oldValue爲null，替換value，否則不替換。
* 4.3返回記錄下來的節點的value。
* 5.如果沒有找到key映射的節點（2、3步中講了，這種情況會插入到hashMap中），插入節點後size會加1，這時要檢查size是否大於臨界值threshold，如果大於會使用resize方法進行擴容。
* @param onlyIfAbsent 如果爲true，即使指定參數key在map中已經存在，也不會替換value
* @param evict 如果爲false，數組table在創建模式中
* @return 如果value被替換，則返回舊的value，否則返回null。當然，可能key對應的value就是null。
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K, V>[] tab;
Node<K, V> p;
int n, i;
//如果哈希表爲空，調用resize()創建一個哈希表，並用變量n記錄哈希表長度
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/**
* 如果指定參數hash在表中沒有對應的桶，即爲沒有碰撞
* Hash函數，(n - 1) & hash 計算key將被放置的槽位
* (n - 1) & hash 本質上是hash % n，位運算更快
*/
if ((p = tab[i = (n - 1) & hash]) == null)
//直接將鍵值對插入到map中即可
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，用e來記錄
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;
}
// 鏈表節點的<key, value>與put操作<key, value>相同時，不做重複操作，跳出循環
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 找到或新建一個key和hashCode與插入元素相等的鍵值對，進行put操作
if (e != null) { // existing mapping for key
// 記錄e的value
V oldValue = e.value;
/**
* onlyIfAbsent爲false或舊值爲null時，允許替換舊值，否則無需替換
*/
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); // 訪問後回調
return oldValue;// 返回舊值
}
}
// 更新結構化修改信息
++modCount;
// 鍵值對數目超過閾值時，進行rehash
if (++size > threshold)
resize();
// 插入後回調
afterNodeInsertion(evict);
return null;
}
如何刪除節點
- HashMap的數據結構分爲兩種，一是鏈表，二是紅黑樹。所以在刪除節點前先判定是哪一種數據結構，再使用其刪除的方法。
- 鏈表的刪除，使用鏈表刪除元素的方式刪除node
p.next = node.next; - 紅黑樹的刪除則調用removeTreeNode，內置的紅黑樹節點刪除方法。具體請了解上B站了解紅黑樹。
/**
* 刪除hashMap中key映射的node
* remove方法的實現可以分爲三個步驟：
* 1.通過 hash(Object key)方法計算key的哈希值。
* 2.通過 removeNode 方法實現功能。
* 3.返回被刪除的node的value。
*
* @param key 參數key
* @return 如果沒有映射到node，返回null，否則返回對應的value
*/
public V remove(Object key) {
Node<K, V> e;
//根據key來刪除node。removeNode方法的具體實現在下面
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**
* Map.remove和相關方法的實現需要的方法
* removeNode方法的步驟總結爲:
* 1.如果數組table爲空或key映射到的桶爲空，返回null。
* 2.如果key映射到的桶上第一個node的就是要刪除的node，記錄下來。
* 3.如果桶內不止一個node，且桶內的結構爲紅黑樹，記錄key映射到的node。
* 4.桶內的結構不爲紅黑樹，那麼桶內的結構就肯定爲鏈表，遍歷鏈表，找到key映射到的node，記錄下來。
* 5.如果被記錄下來的node不爲null，刪除node，size-1被刪除。
* 6.返回被刪除的node。
*
* @param hash key的哈希值
* @param key key的哈希值
* @param value 如果 matchValue 爲true，則value也作爲確定被刪除的node的條件之一，否則忽略
* @param matchValue 如果爲true，則value也作爲確定被刪除的node的條件之一
* @param movable 如果爲false，刪除node時不會刪除其他node
* @return 返回被刪除的node，如果沒有node被刪除，則返回null（針對紅黑樹的刪除方法）
*/
final Node<K, V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K, V>[] tab;
Node<K, V> p;
int n, index;
//如果數組table不爲空且key映射到的桶不爲空
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K, V> node = null, e;
K k;
V v;
//如果桶上第一個node的就是要刪除的node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//記錄桶上第一個node
node = p;
else if ((e = p.next) != null) {//如果桶內不止一個node
//如果桶內的結構爲紅黑樹
if (p instanceof TreeNode)
//記錄key映射到的node
node = ((TreeNode<K, V>) p).getTreeNode(hash, key);
else {//如果桶內的結構爲鏈表
do {//遍歷鏈表，找到key映射到的node
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
//記錄key映射到的node
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//如果得到的node不爲null且(matchValue爲false||node.value和參數value匹配)
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果桶內的結構爲紅黑樹
if (node instanceof TreeNode)
//使用紅黑樹的刪除方法刪除node
((TreeNode<K, V>) node).removeTreeNode(this, tab, movable);
else if (node == p)//如果桶的第一個node的就是要刪除的node
//刪除node
tab[index] = node.next;
else//如果桶內的結構爲鏈表，使用鏈表刪除元素的方式刪除node
p.next = node.next;
++modCount;//結構性修改次數+1
--size;//哈希表大小-1
afterNodeRemoval(node);
return node;//返回被刪除的node
}
}
return null;//如果數組table爲空或key映射到的桶爲空，返回null。
}
技術細節（你應該知道的）
treeifyBin鏈表如何轉化爲紅黑樹
hashmap轉紅黑樹的兩個條件，
一個是鏈表長度到8if (binCount >= TREEIFY_THRESHOLD - 1) treeifyBin(tab, hash);
一個是數組長度到64(n = tab.length) < MIN_TREEIFY_CAPACITY)
- 判斷是否需要擴容
- 如果符合轉化爲紅黑樹的條件，遍歷鏈表，替換鏈表node爲樹node，建立雙向鏈表
final void treeifyBin(Node<K, V>[] tab, int hash) {
int n, index;
Node<K, V> e;
//如果桶數組table爲空，或者桶數組table的長度小於MIN_TREEIFY_CAPACITY，不符合轉化爲紅黑樹的條件
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//擴容
resize();
//如果符合轉化爲紅黑樹的條件，而且hash對應的桶不爲null
else if ((e = tab[index = (n - 1) & hash]) != null) {
// 紅黑樹的頭、尾節點
TreeNode<K, V> hd = null, tl = null;
//遍歷鏈表
do {
//替換鏈表node爲樹node，建立雙向鏈表
TreeNode<K, V> p = replacementTreeNode(e, 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);
}
}
爲什麼要擴容
爲了降低hash碰撞的概率，當hashmap中的元素個數其0.75倍時，就拓展一倍，即*2。
- 當hashmap中的元素越來越多的時候，碰撞的機率也就越來越高（因爲數組的長度是固定的），所以爲了提高查詢的效率，就要對hashmap的數組進行擴容，數組擴容這個操作也會出現在ArrayList中，所以
這是一個通用的操作。 - 數組擴容會影響性能：原數組中的數據必須重新計算其在新數組中的位置，並放進去，這就是resize。
- hashmap什麼時候擴容：當hashmap中的元素個數超過數組大小loadFactor時，就會進行數組擴容，loadFactor的默認值爲0.75，數組默認大小爲16，那麼當hashmap中元素個數超過160.75=12的時候，就把數組的大小擴展爲2*16=32，即擴大一倍，然後重新計算每個元素在數組中的位置。
/**
* 對table進行初始化或者擴容。
* 如果table爲null，則對table進行初始化
* 如果對table擴容，因爲每次擴容都是翻倍，與原來計算（n-1）&hash的結果相比，節點要麼就在原來的位置，要麼就被分配到“原位置+舊容量”這個位置
* resize的步驟總結爲:
* 1.計算擴容後的容量，臨界值。
* 2.將hashMap的臨界值修改爲擴容後的臨界值
* 3.根據擴容後的容量新建數組，然後將hashMap的table的引用指向新數組。
* 4.將舊數組的元素複製到table中。
*
* @return the table
*/
final Node<K, V>[] resize() {
//新建oldTab數組保存擴容前的數組table
Node<K, V>[] oldTab = table;
//獲取原來數組的長度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//原來數組擴容的臨界值
int oldThr = threshold;
int newCap, newThr = 0;
//如果擴容前的容量 > 0
if (oldCap > 0) {
//如果原來的數組長度大於最大值(2^30)
if (oldCap >= MAXIMUM_CAPACITY) {
//擴容臨界值提高到正無窮
threshold = Integer.MAX_VALUE;
//無法進行擴容，返回原來的數組
return oldTab;
//如果現在容量的兩倍小於MAXIMUM_CAPACITY且現在的容量大於DEFAULT_INITIAL_CAPACITY
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//臨界值變爲原來的2倍
newThr = oldThr << 1;
} else if (oldThr > 0) //如果舊容量 <= 0，而且舊臨界值 > 0
//數組的新容量設置爲老數組擴容的臨界值
newCap = oldThr;
else { //如果舊容量 <= 0，且舊臨界值 <= 0，新容量擴充爲默認初始化容量，新臨界值爲DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY
newCap = DEFAULT_INITIAL_CAPACITY;//新數組初始容量設置爲默認值
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//計算默認容量下的閾值
}
// 計算新的resize上限
if (newThr == 0) {//在當上面的條件判斷中，只有oldThr > 0成立時，newThr == 0
//ft爲臨時臨界值，下面會確定這個臨界值是否合法，如果合法，那就是真正的臨界值
float ft = (float) newCap * loadFactor;
//當新容量< MAXIMUM_CAPACITY且ft < (float)MAXIMUM_CAPACITY，新的臨界值爲ft，否則爲Integer.MAX_VALUE
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
(int) ft : Integer.MAX_VALUE);
}
//將擴容後hashMap的臨界值設置爲newThr
threshold = newThr;
//創建新的table，初始化容量爲newCap
@SuppressWarnings({"rawtypes", "unchecked"})
Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
//修改hashMap的table爲新建的newTab
table = newTab;
//如果舊table不爲空，將舊table中的元素複製到新的table中
if (oldTab != null) {
//遍歷舊哈希表的每個桶，將舊哈希表中的桶複製到新的哈希表中
for (int j = 0; j < oldCap; ++j) {
Node<K, V> e;
//如果舊桶不爲null，使用e記錄舊桶
if ((e = oldTab[j]) != null) {
//將舊桶置爲null
oldTab[j] = null;
//如果舊桶中只有一個node
if (e.next == null)
//將e也就是oldTab[j]放入newTab中e.hash & (newCap - 1)的位置
newTab[e.hash & (newCap - 1)] = e;
//如果舊桶中的結構爲紅黑樹
else if (e instanceof TreeNode)
//將樹中的node分離
((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
else { //如果舊桶中的結構爲鏈表,鏈表重排，jdk1.8做的一系列優化
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 {// 原索引+oldCap
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;
}
HashMap的長度爲什麼要是2的n次方
參考hashtable（hash函數），hashcode計算時使用與運算速度更快。(h = key.hashCode()) ^ (h >>> 16)
爲什麼會需要hashmap
待補
hashmap在JDK歷史版本中的改動原因
待補
參考：
- https://blog.csdn.net/Yoga0301/article/details/84452104
- https://github.com/wupeixuan/JDKSourceCode1.8.git