HashMap链表树化时机 : (binCount ＞= TREEIFY_THRESHOLD - 1)

混淆点

当链表长度大于8时树化，然而看源码的时候不仔细很容易产生困惑！
源码中链表树化的判断：让我疑惑链表红黑树化的条件是大于还是大于等于？ 值是7还是8？

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    treeifyBin(tab, hash);
//TREEIFY_THRESHOLD ：树化阈值
static final int TREEIFY_THRESHOLD = 8;

先说正确答案：
链表树化（treeifyBin）发生在，链表长度大于8
并且treeifyBin方法内会判断，只有在数组长度大于等于64才会真去树化，否则会先扩容

 
 

所以

以下说法是错误的：

 

 

源码分析（忽略无关代码）

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    Node<K,V>[] tab ; int n, i;
    
    Node<K,V> p(指向链表头节点); 
    
    // table未初始化或者长度为0，进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;


    // 确定元素存放在哪个桶中，桶为空，新生成结点放入桶中
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);


    // 桶中已经存在元素 ： p(指向链表头节点)
    else {
        Node<K,V> e; K k;
        // 比较桶中第一个元素p与要插入元素的key是否相等，key相等则此次put为覆盖操作
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                // 将第一个元素赋值给e，用e来记录
                e = p;


        // key不相等；头节点p为红黑树结点，则此次put为向红黑树中插入节点
        else if (p instanceof TreeNode)
            // 放入树中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);


        // key不相等；头节点p为链表结点，则此次put为向链表中插入节点（树化发生在此处）
        else {
            // 遍历链表，只在两种情况下才会跳出循环
            for (int binCount = 0; ; ++binCount) {
            
            	//第一种：已经遍历到尾部,在最后插入新节点跳出，因节点数量+1 判断是否需要树化
                if ((e = p.next) == null) { 
                
                    // 在尾部插入新结点
                    p.next = newNode(hash, key, value, null);
                    
                    // 判断是否需要树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                        
                    // 跳出循环
                    break;
                }
                
                
                // 第二种：e指向的节点与要插入节点的key相同，此次put为覆盖操作
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出循环
                    break;


                // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                p = e;
            }
        }


        // 表示在桶中找到相同key值的结点，覆盖旧节点
        if (e != null) {
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
        //忽略无关代码
}

重点在这一段代码

			// 遍历链表，只在两种情况下才会跳出循环
			 for (int binCount = 0; ; ++binCount) {
            
            	//第一种：已经遍历到尾部,在最后插入新节点跳出，因节点数量+1 判断是否需要树化
                if ((e = p.next) == null) { 
                
                    // 在尾部插入新结点
                    p.next = newNode(hash, key, value, null);
                    
                    // 判断是否需要树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                        
                    // 跳出循环
                    break;
                }
                
                
                // 第二种：e指向的节点与要插入节点的key相同，此次put为覆盖操作
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等，跳出循环
                    break;


                // 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
                p = e;
            }

遍历过程中p从第一个节点遍历到最后一个节点
但由于binCount是从0开始计数，所以在做树化判断时binCount的值等于 链表长度 - 1（注意此时的链表长度没有算新插入的节点）
判断条件为 binCount >= TREEIFY_THRESHOLD - 1 => binCount+1(链表长度) >= TREEIFY_THRESHOLD

但此时链表新插入了一个节点

 p.next = newNode(hash, key, value, null);

所以链表树化的那一刻，它的真实长度应该时binCount+1+1 => 链表长度>TREEIFY_THRESHOLD(8)

即：

链表长度大于8时，treeifyBin()方法被调用
（在做树化判断时，链表长度 = binCount+1（从零计数）+1（新插入节点） = bincount +2）
（判断条件： (bincount >= 8-1) => (bincount>=7) => (bincount+2>=9) => (链表长度>=9) 长度是整数 大于等于9也就是大于8）