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，不满足转链表条件，需要重新树化。