HashMap到底是怎麼put 的？
歡迎有時間去來我的csdn部落格做客討論~ blog.csdn.net/doujinlong1
關於HashMap中的紅黑樹這裡不做過多討論
本次討論的是jdk1.8的原始碼HashMap.put 直接上原始碼，
HashMap.put會直接呼叫putVal(hash(key), key, value, false, true); 直接開始看：
程式碼片段一
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// putVal(hash(key), key, value, false, true);
// hash是key的hash值，具體演算法見方法，key是put時的key，value是put的value,onlyIfAbSent = false,evict = true;
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果為該Map為空尚未初始化，則呼叫resize進行初始化，n = 初始化後table的大小16。
//==========================resize過程見程式碼片段二===================================
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 如果在計算出來的table陣列的第i個位置上，p = null 還沒有節點，則建立一個節點即可。（i = (n - 1) & hash）,這個計算方法是完成了類似%的操作，並且因為n-1始終是2進位制的1111...,所以在table陣列上的位置均分。
// p = table[i];
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 如果在第i個位置上已有節點，即p!=null則進入else方法塊。
else {
Node<K,V> e; K k;
// 陣列table第i個元素的第一個節點 的hash值 = 要put的key的hash值，要put的key如果等於在這個節點上的key（包括null情況，這也就說明，hashMap的key可以為null，但是隻能有一個）。
// 在這種情況下則將當前節點用e指代
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果p（table第i個元素的第一個節點 的hash值 ） 為 TreeNode，則將新節點放入HashMap裡自定義的紅黑樹。putTreeVal方法會自己完成樹的平衡
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// table第i個元素的第一個節點 不滿足上述情況（第一個節點和put進來的key不一樣 + 不為TreeNode），則進入這個方法塊。
else {
//遍歷table第i個元素上的連結串列，從頭開始遍歷，見第一行e = p.next 和for迴圈最後一行p = e。
for (int binCount = 0; ; ++binCount) {
//遍歷到p 的next節點為null的時候，則 p.next指向新節點。（所以hashMap的連結串列上有新節點時都是在連結串列尾部插入。）
//e = p.next ；p.next = newNode 這句則是將當前節點記錄，用e指代。
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//插入到binCount到7的時候，即連結串列上的元素為第八個，插入了第九個的時候，則將這個連結串列轉變為紅黑樹，使用treeifyBin方法。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果迴圈到一個節點，且滿足 【hash值 = 要put的key的hash值，要put的key如果等於在這個節點上的key（包括null情況，這也就說明，hashMap的key可以為null，但是隻能有一個）】
// 則將當前節點記錄，用e指代。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//由上面的程式碼執行完，則e肯定是指代了一個當前節點，key與要put的key一致，如果已有值，則value 是oldValue,如果沒有，則是新的value
// 下面的程式碼執行結束，則返回一個value（如果已有則為old,否則為插入的）可以使用map.put(k,v) == v 來判斷hashMap以前有沒有儲存過這個key。
//並返回。
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//預留方法，LinkedList使用
afterNodeAccess(e);
return oldValue;
}
}
// 如果是【在第i個位置上已有節點，即p!=null則進入else方法塊。】這個條件，則會在上面return，所以在這裡的程式碼都是第i個節點上沒有資料的情況才會執行，即resize這個方法只會在往陣列的一個新位置上插入資料的時候才會觸發（其實是廢話，resize就是table的size不夠的情況）。
++modCount;
//size為table陣列上有資料的數量，如果size大於threshold時則擴容。
if (++size > threshold)
//=====================================這裡擴容時的resize見程式碼片段三====================================
resize();
//預留方法，LinkedList使用
afterNodeInsertion(evict);
//返回null。
return null;
}
複製程式碼程式碼片段二
// 在初始化的時候的呼叫場景
final Node<K,V>[] resize() {
//空
Node<K,V>[] oldTab = table;
// 0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//0
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;
//進去，設定容量為預設容量為16 ，threshold = 12
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是成員變數
threshold = newThr;
//建立出一個newTab，陣列大小為 newCap = 16
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//將變數 table 設定為剛才建立出來的newTab。 table 是成員變數。
//總結一下，這個方法在初始化的時候只是將table設定為初始化的大小為16的陣列，threshold =12。
table = newTab;
//不進去
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;
}
複製程式碼程式碼片段三
final Node<K,V>[] resize() {
//將要擴容的table，容量到達0.75*capacity
Node<K,V>[] oldTab = table;
//當前的capacity
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//當前的threshold
int oldThr = threshold;
//設定新的容量和threshold
int newCap, newThr = 0;
//擴容時進入
if (oldCap > 0) {
//如果已經到達int最大值，則只能這樣了...直接返回不擴容（所以，也不是到了就擴容，畢竟有上限）。
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果還沒到，則新的容量設定為老的容量的2倍，threshold也變成以前的兩倍（16->32...）
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;
//建立一個新的陣列，容量為新容量（2倍老容量）
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//這裡將成員變數設定為新的陣列（在這時候如果put，則可能會有問題，想想）
table = newTab;
//擴容時進入
if (oldTab != null) {
//遍歷舊的陣列
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//用e指向舊陣列的遍歷到的位置，如果不為空，則進入，為空則不用管。
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果e.next==null,則是隻有一個元素，則只需要將這個元素 e 平移到新陣列上即可。newTab[e.hash & (newCap - 1)] = e
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//如果這個位置上的儲存結構是樹結構，則進行分割這個樹結構到新陣列上，與下面的else情況類似，分為在新陣列的老位置還是新位置。
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//除此的情況，不是隻有1個元素，且不是樹結構（連結串列大小小於8），則進入。
else { // preserve order
//這裡的處理我第一次看到的時候覺得很是佩服。
//定義兩個Node,一個低位Node loHead ，一個高位Node hiNode，為什麼高，為什麼低下面說。
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
// 迴圈遍歷e開頭的連結串列,直到 e 的最後一個節點
do {
next = e.next;
//遍歷過程中，如果 e 滿足 (e.hash & oldCap) == 0 則將這個節點放到 loHead連結串列。
//這裡這麼處理的原因是 oldCap 一定是2的冪次方，在2進位制下為10000....這種，所以當e.hash如果滿足(e.hash & oldCap) == 0 時則說明，e的高位也為0。而newCap-1 的二進位制是1111111...（與oldCap的長度一樣）
//比如16擴容後變成32 ，則oldCap = 10000，newCap -1 = 11111;
//在這種情況下，前面說過e的高位為0。其實e.hash &（newCap -1）實際上的最高位肯定 =0 ，而如果高位等於0，則e.hash &（newCap -1） == e.hash &（oldCap -1）,這個元素則新舊陣列table中的位置肯定是一個。
// 所以還在第j 個位置。
//如果不為0 ，則高位為1，則e.hash &（newCap -1） = e.hash &（oldCap -1） + 10000...（oldCap的二進位制）
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 不滿足的 (e.hash & oldCap) != 0 則將這個節點放到 hiTail 連結串列。
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//遍歷完畢，if滿足部分進入陣列的原有位置 j ，else 滿足部分進入 陣列新位置 j+oldCap 。
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//返回新陣列，結束擴容。
return newTab;
}複製程式碼