1.在HashMap的resize方法中，遍歷舊數組的節點元素，判斷如果是紅黑樹節點，則調用TreeNode的split方法，來判斷是否需要將原來的紅黑樹節點拆分爲兩個節點（分別爲新數組中位置j和j+oldCap）
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; // 擴容位原數組的兩倍大小
}
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;
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;
}
2.進入TreeNode的split方法：
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this;
// 將紅黑樹節點拆分成高低位鏈表
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
if ((e.hash & bit) == 0) {//1
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);//2
else {
tab[index] = loHead;
if (hiHead != null) // (else is already treeified)//3
loHead.treeify(tab);
}
}
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}
q1:上圖註釋1(e.hash & bit) == 0的這樣處理的含義？
TreeNode繼承Node，樹節點同時依然是鏈表節點，未擴容之前的舊數組中元素存放到同一個位置的鏈表中，並不意味這這些節點的hash值都相同；計算元素在數組中下標的公式爲hash&(cap-1)；而hashMap的容量由內部保障肯定爲2的整數倍,這裏以默認容量16舉例：
元素1 元素 2
cap-1：01111 01111
hash ：01100 11100
result：01100 01100
元素1和元素2的低5位和oldCap-1的位與值結果相同，所以它們在舊數組下的下標相同，是同一個鏈表下的節點；但是hash值不同同，而新數組的大小newCap擴容爲原來的兩倍，也就是32，轉化成二進制100000；帶入到下標計算公式，元素2在新數組的下標正好比元素1在新數組的位置多16，多出了oldCap的大小；
元素1 元素 2
oldCap: 10000 10000
hash: 01100 11100
result： 00000 10000
所以e.hash & bit == 0，可用來判斷元素是在新數組的原位置p，還是p+oldCap;
q2:註釋2處的去樹化處理tab[index] = loHead.untreeify(map)怎麼理解？
當確定了低位鏈表處的節點數量小於紅黑樹轉鏈表的閾值6時，需要進行對應的轉換，至於前面提到的樹節點本身也是鏈表節點，是否需要轉，這裏個人理解是，不轉換爲簡單的鏈表節點，刪除或者更新元素處理複雜。效率低，代碼中也確實只做了簡單的轉換處理：
final Node<K,V> untreeify(HashMap<K,V> map) {
Node<K,V> hd = null, tl = null;
for (Node<K,V> q = this; q != null; q = q.next) {
Node<K,V> p = map.replacementNode(q, null);//轉換爲普通節點
if (tl == null)
hd = p;
else
tl.next = p;
tl = p;
}
return hd;
}
q3：註釋三處的非空判斷該怎麼理解？
起初讀到這段代碼的時候，感覺很難理解，網上找的一些答案又解釋的似是而非，無法讓人信服，比如大部分直譯爲高位鏈表爲空，未完成，低位鏈表不能轉紅黑樹；但是這無法解釋後面的else is already treeified原生註解；這裏個人理解，高位鏈表如果爲空，說明舊數組下的紅黑樹中的元素在新數組中仍然全部在同一個位置，且先後順序沒有改變，也就是註釋中的已經樹化了，沒有必要再次樹化；而當高位節點不爲空，說明原鏈表元素被拆分了，切地位紅黑樹節點個數大於6，不滿足轉鏈表條件，需要重新樹化。