结论：

1. HashMap会在put元素的时候判断当前链表长度是否达到了树的阈值且数组长度大于最小转换树的长度，如果满足触发转换树的操作
2. 通过treeifybin方法将Node节点的链表转换成TreeNode节点的双向链表
3. 通过treeify方法将TreeNode节点的链表转换成红黑树
4. 保证数组槽的第一个节点是红黑树的根节点

具体操作：

• putval方法（删除了无关代码）：对链表进行遍历，判断是否达到了树的阈值，如果达到了调用treeifyBin方法

   for (int binCount = 0; ; ++binCount) {
       if ((e = p.next) == null) {
           p.next = newNode(hash, key, value, null);
           if (binCount >= TREEIFY_THRESHOLD - 1) // 如果长度到达树的阈值，触发转红黑树操作
               treeifyBin(tab, hash);
           break;
       }
       if (e.hash == hash && // 如果发现key和hash都相同的就跳出
           ((k = e.key) == key || (key != null && key.equals(k))))
           break;
       p = e;
   }
  

• treeifyBin方法：如果数组长度不满足转换成树的最小长度，先进行数组扩容（因为数组扩容也就变向的减小了链表的长度），如果满足条件，会先将单向node节点链表转成双向treeNode节点链表，然后调用treeify方法

   final void treeifyBin(Node<K,V>[] tab, int hash) {
       int n, index; Node<K,V> e;
       if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
           resize();
       else if ((e = tab[index = (n - 1) & hash]) != null) {
           TreeNode<K,V> hd = null, tl = null;
           do {
               TreeNode<K,V> p = replacementTreeNode(e, null);
               if (tl == null)
                   hd = p;
               else {
                   p.prev = tl;
                   tl.next = p;
               }
               tl = p;
           } while ((e = e.next) != null);
           if ((tab[index] = hd) != null)
               hd.treeify(tab);
       }
   }
  

  转换前
  转换后
  

• treeify方法：通过key和value比较得到节点应该放在树的左面还是右面，插入后调用balanceInsertion方法进行树的平衡操作，代码这里就不展示了，就是红黑树的那几个基本情况

    final void treeify(Node<K,V>[] tab) {
        TreeNode<K,V> root = null;
        // 遍历链表节点
        for (TreeNode<K,V> x = this, next; x != null; x = next) {
            next = (TreeNode<K,V>)x.next;
            x.left = x.right = null;
            if (root == null) {
                x.parent = null;
                x.red = false;
                root = x;
            }
            else {
                K k = x.key;
                int h = x.hash;
                Class<?> kc = null;
                // 遍历树节点
                for (TreeNode<K,V> p = root;;) {
                    int dir, ph; 
                    K pk = p.key;
                    // 通过key和value比较得到节点应该放在树的左面还是右面
                    if ((ph = p.hash) > h)
                        dir = -1;
                    else if (ph < h)
                        dir = 1;
                    else if ((kc == null &&
                              (kc = comparableClassFor(k)) == null) ||
                             (dir = compareComparables(kc, k, pk)) == 0)
                        dir = tieBreakOrder(k, pk);
  
                    TreeNode<K,V> xp = p;
                    if ((p = (dir <= 0) ? p.left : p.right) == null) {
                        x.parent = xp;
                        if (dir <= 0)
                            xp.left = x;
                        else
                            xp.right = x;
                        root = balanceInsertion(root, x); // 插入平衡调整
                        break;
                    }
                }
            }
        }
        moveRootToFront(tab, root); // 将树的根节点指向数组
    }
  

• moveRootToFront方法：保证数组槽的第一个元素是红黑树的根节点

  static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
    int n;
    if (root != null && tab != null && (n = tab.length) > 0) {
        int index = (n - 1) & root.hash;
        TreeNode<K,V> first = (TreeNode<K,V>)tab[index]; // 获取数组的第一个节点
        if (root != first) { // 如果树的根节点和链表的第一个节点不同
            Node<K,V> rn;
            tab[index] = root;
            TreeNode<K,V> rp = root.prev;
            if ((rn = root.next) != null)
                ((TreeNode<K,V>)rn).prev = rp;
            if (rp != null)
                rp.next = rn;
            if (first != null)
                first.prev = root;
            root.next = first;
            root.prev = null;
        }
        assert checkInvariants(root); // 验证红黑树的准确性
    }
  }