HashMap 獲取數據
分析get方法之前得先了解 hash(key) 方法和 getNode(hash, key) 方法 ，hash() 方法是獲取對應的下標位置的必須步驟,
找到對應的 node 在去遍歷查找 對應相同的 key 值.
hash(Object key) 方法:
1、（key的哈希值）異或(^)（哈希值 按位右移16）得到哈希值 獲取到哈希值
（key 哈希值 ^ (key 哈希值 >>> 16)）
/**
* HashMap中鍵值對的存儲形式爲鏈表節點，hashCode相同的節點（位於同一個桶）用鏈表組織
* hash方法分爲三步:
* 1.取key的hashCode
* 2.key的hashCode高16位異或低16位
* 3.將第一步和第二步得到的結果進行取模運算。
*/
static final int hash(Object key) {
int h;
//計算key的hashCode, h = Objects.hashCode(key)
//h >>> 16表示對h無符號右移16位，高位補0，然後h與h >>> 16按位異或
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
getNode(int hash, Object key) 方法:
2、（table長度 - 1）與(&) hash(key)哈希值 能獲取到對應的 bucket 桶. 爲null就直接返回。
- 2.1、判斷當前的Node對象 哈希值是否相等, 並判斷key 是否 equals() 相等.
- 2.2、不相等則尋找下一個節點 next .（先判斷是否爲樹節點，是則通過樹節點方法查找）
/**
* 根據key的哈希值和key獲取對應的節點
* getNode可分爲以下幾個步驟：
* 1.如果哈希表爲空，或key對應的桶爲空，返回null
* 2.如果桶中的第一個節點就和指定參數hash和key匹配上了，返回這個節點。
* 3.如果桶中的第一個節點沒有匹配上，而且有後續節點
* 3.1如果當前的桶採用紅黑樹，則調用紅黑樹的get方法去獲取節點
* 3.2如果當前的桶不採用紅黑樹，即桶中節點結構爲鏈式結構，遍歷鏈表，直到key匹配
* 4.找到節點返回null，否則返回null。
*
* @param hash 指定參數key的哈希值
* @param key 指定參數key
* @return 返回node，如果沒有則返回null
*/
final Node<K, V> getNode(int hash, Object key) {
Node<K, V>[] tab;
Node<K, V> first, e;
int n;
K k;
//如果哈希表不爲空，而且key對應的桶上不爲空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果桶中的第一個節點就和指定參數hash和key匹配上了
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
//返回桶中的第一個節點
return first;
//如果桶中的第一個節點沒有匹配上，而且有後續節點
if ((e = first.next) != null) {
//如果當前的桶採用紅黑樹，則調用紅黑樹的get方法去獲取節點
if (first instanceof TreeNode)
return ((TreeNode<K, V>) first).getTreeNode(hash, key);
//如果當前的桶不採用紅黑樹，即桶中節點結構爲鏈式結構
do {
//遍歷鏈表，直到key匹配
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
//如果哈希表爲空，或者沒有找到節點，返回null
return null;
}
put() 方法
- 如果哈希表爲空，調用resize()創建一個哈希表。
- 如果指定參數hash在表中沒有對應的桶，即爲沒有碰撞，直接將鍵值對插入到哈希表中即可。
- 如果有碰撞，遍歷桶，找到key映射的節點
3.1 桶中的第一個節點就匹配了，將桶中的第一個節點記錄起來。
3.2 如果桶中的第一個節點沒有匹配，且桶中結構爲紅黑樹，則調用紅黑樹對應的方法插入鍵值對。
3.3 如果不是紅黑樹，那麼就肯定是鏈表。遍歷鏈表，如果找到了key映射的節點，就記錄這個節點，退出循環。如果沒有找到，在鏈表尾部插入節點。插入後，如果鏈的長度大於等於TREEIFY_THRESHOLD這個臨界值，則使用treeifyBin方法把鏈表轉爲紅黑樹。- 如果找到了key映射的節點，且節點不爲null
4.1 記錄節點的vlaue。
4.2 如果參數onlyIfAbsent爲false，或者oldValue爲null，替換value，否則不替換。
4.3 返回記錄下來的節點的value。- 如果沒有找到key映射的節點（2、3步中講了，這種情況會插入到hashMap中），插入節點後size會加1，這時要檢查size是否大於臨界值threshold，如果大於會使用resize方法進行擴容。
/**
* 將指定參數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方法返回的結果。
*
* @param key 指定key
* @param value 指定value
* @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 hash 指定參數key的哈希值
* @param key 指定參數key
* @param value 指定參數value
* @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;
}
resize()
resize() 方法：
1、當前長度是否大於0，表示有數據。
- 1.1、如果數組長度超過最大數值 Max，設置它的下個調整容量大小爲最大值 Max。
- 1.2、如果數組長度小於最大數值 Max 和 大於默認值 16 時, 設置它的下個調整容量大小爲當前的2倍。
2、閾值大於0時， 初始容量設置爲閾值
3、閾值等於0時， 設置默認值
- 3.1、默認長度：16
- 3.2、默認閾值：16 * 0.75f
4、設置新的閾值。
5、設置新的數組長度。
/**
* 對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;
}
將鏈表轉化爲紅黑樹 treeifyBin(Node<K, V>[] tab, int hash)
/**
* 將鏈表轉化爲紅黑樹
*/
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);
}
}
HashMap 參數分析
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默認的初始容量16 -必須是2的冪。
static final int MAXIMUM_CAPACITY = 1 << 30; //最大容量，如果較高的值是由任何帶有參數的構造函數隱式指定的。必須是2的冪<= 1<<30。
static final float DEFAULT_LOAD_FACTOR = 0.75f; //在構造函數中未指定時使用的負載因子。
static final int TREEIFY_THRESHOLD = 8; //樹的臨界值
static final int UNTREEIFY_THRESHOLD = 6; //在調整大小操作期間取消(分割)存儲庫的存儲計數閾值。應小於TREEIFY_THRESHOLD，並最多6個網格與收縮檢測下去除。
static final int MIN_TREEIFY_CAPACITY = 64; //最小的表容量，可爲容器進行樹狀排列。
transient Node<K, V>[] table; //表，在第一次使用時初始化，並根據需要調整大小。分配時，長度總是2的冪。
transient Set<Map.Entry<K, V>> entrySet; //保存緩存
transient int size; //這個映射中包含的鍵值映射的數量。
transient int modCount; //修改的次數
int threshold; //調整大小的下一個大小值(容量*負載因子)。
final float loadFactor; //哈希表的負載因子。
//在第一次請求該視圖時，每個字段都被初始化爲包含適當視圖的實例。視圖是無狀態的，因此沒有理由創建多個視圖。
transient volatile Set<K> keySet; (AbstractMap)
transient volatile Collection<V> values; (AbstractMap)
//基本哈希bin節點，用於大多數條目。(參見下面的TreeNode子類，以及LinkedHashMap中的條目子類)
static class Node<K, V> implements Map.Entry<K, V> {
final int hash; //哈希值
final K key; //鍵
V value; //值
Node<K, V> next;//下一個值
}
//該方法保證了容量的長度是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;
}