HashMap源码解读扩容树化触发条件

源码分析：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                            boolean evict) {
                 Node<K,V>[] tab; Node<K,V> p; int n, i;  //辅助变量
                // 判断table表是否为空或者长度是否为0，就扩容16
                 if ((tab = table) == null || (n = tab.length) == 0)
                     n = (tab = resize()).length;
                    // 取出hash值对应的table的索引位置的Node，如果为空，就直接把加入的k-v创建成一个Node，加入该位置即可
                 if ((p = tab[i = (n - 1) & hash]) == null)
                     tab[i] = newNode(hash, key, value, null);
                 else {
                     Node<K,V> e; K k;
                     //如果table中的已存在的hash值和新加入来key的hash值相同并且存在现有的key和想要加入来的key是同一个对象，或者key不为null并且equals返回值为真
                     //就认为不能加入
                     if (p.hash == hash &&
                         ((k = p.key) == key || (key != null && key.equals(k))))
                         e = p;
                         如果table已有的Node是红黑树，难么就按照红黑树的方式处理
                     else if (p instanceof TreeNode)
                         e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                     else {
                     // 遍历链表，只在两种情况下才会跳出循环
                         for (int binCount = 0; ; ++binCount) {
                         //如果原有的Node为null，就把因加入的key追加在后面，因节点数量+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;
                             }
                             //如果table中的已存在的hash值和新加入来key的hash值相同并且存在现有的key和想要加入来的key是同一个对象，或者key不为null并且equals返回值为真
                               //就认为不能加入
                             if (e.hash == hash &&
                                 ((k = e.key) == key || (key != null && key.equals(k))))
                                 break;
                             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;
                 }
                 }
                 ++modCount;//每增加一个节点，size++
                 //如果size（）大于临界值，就会进行扩容
                 if (++size > threshold)
                     resize();
                 afterNodeInsertion(evict);
                 return null;
                 
             }

关键代码：

//遍历链表，只在两种情况下才会跳出循环
                         for (int binCount = 0; ; ++binCount) {
                        // 如果原有的Node为null，就把因加入的key追加在后面，因节点数量+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;
                             }
                            // 如果table中的已存在的hash值和新加入来key的hash值相同并且存在现有的key和想要加入来的key是同一个对象，或者key不为null并且equals返回值为真
                             //  就认为不能加入
                             if (e.hash == hash &&
                                 ((k = e.key) == key || (key != null && key.equals(k))))
                                 break;
                             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;
                 }
                 }
                 ++modCount;//每增加一个节点，size++
                 //如果size（）大于临界值，就会进行扩容
                 if (++size > threshold)
                     resize();
                 afterNodeInsertion(evict);
                 return null;

结论 

新加入的k-v进行遍历，如果原有链表的Node为null，就把新加入的key追加在后面，因节点数量+1 判断是否需要树化，链表树化（treeifyBin）发生在，链表长度大于8
并且treeifyBin方法内会判断，只有在数组长度大于等于64才会真去树化，否则会先扩容。