一篇文章彻底拆解Java HashMap扩容机制

// 伪代码逻辑
if (++size > threshold)
    resize();

if (e.next == null)
    newTab[e.hash & (newCap - 1)] = e;

// HashMap.resize() 方法片段 - 链表迁移
for (int j = 0; j < oldCap; ++j) {          // 遍历旧数组每个桶
    Node<K,V> e;
    if ((e = oldTab[j]) != null) {          // 桶非空
        oldTab[j] = null;                   // 清空原桶，便于GC
        if (e.next == null)                 // 单节点：直接迁移
            newTab[e.hash & (newCap - 1)] = e;
        else if (e instanceof TreeNode)     // 红黑树：调用split()（见下文）
            ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
        else {                              // ===== 链表迁移核心逻辑 =====
            // 初始化两条新链表的头尾指针
            // lo = low（低位），hi = high（高位）
            Node<K,V> loHead = null, loTail = null;  // 低位链表：新索引 = 原索引
            Node<K,V> hiHead = null, hiTail = null;  // 高位链表：新索引 = 原索引 + oldCap
            Node<K,V> next;
            // 遍历原链表，逐节点拆分
            do {
                next = e.next;  // 1. 保存当前节点的next，防止断链后无法继续遍历
                // 2. 高低位判断：(hash & oldCap) == 0 ?
                //    oldCap是2的幂（如16=0b10000），此操作等价于判断hash的第5位是否为0
                //    - 为0：新索引 = 原索引（低位）
                //    - 非0：新索引 = 原索引 + oldCap（高位）
                if ((e.hash & oldCap) == 0) {
                    // ===== 低位链表插入（尾插法）=====
                    if (loTail == null)       // 首次插入：设置头节点
                        loHead = e;
                    else                      // 非首次：尾节点的next指向当前节点
                        loTail.next = e;
                    loTail = e;               // 更新尾指针为当前节点
                } else {
                    // ===== 高位链表插入（尾插法）=====
                    if (hiTail == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                }
            } while ((e = next) != null);    // 移动到下一个节点，继续遍历
            // 3. 断尾操作：必须将两条链表的尾节点next置为null！
            //    原因：遍历时未断开原链表引用，若不置null可能形成跨桶环形引用
            if (loTail != null) {
                loTail.next = null;          // 低位链表尾部断开
                newTab[j] = loHead;          // 放入新数组的原索引位置
            }
            if (hiTail != null) {
                hiTail.next = null;          // 高位链表尾部断开
                newTab[j + oldCap] = hiHead; // 放入新数组的原索引+oldCap位置
            }
        }
    }
}

/**
 * 红黑树拆分方法（定义在 TreeNode 内部类中）
 * 
 * @param map   当前 HashMap 实例
 * @param tab   扩容后的新数组
 * @param index 原桶在旧数组中的索引
 * @param bit   旧容量 oldCap（2的幂，如16）
 */
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
    // 1. 获取当前桶的树根节点（同时也是双向链表头节点）
    TreeNode<K,V> b = this;
    // 2. 初始化两条新链表的头尾指针（注意：此时仍是TreeNode，非普通Node）
    TreeNode<K,V> loHead = null, loTail = null;  // 低位链表
    TreeNode<K,V> hiHead = null, hiTail = null;  // 高位链表
    // 3. 计数器：记录高低位链表的节点数量，用于后续退化判断
    int lc = 0, hc = 0;
    // ===== 阶段1：按双向链表顺序遍历拆分 =====
    // 注意：这里遍历的是双向链表（通过next指针），不是红黑树结构！
    for (TreeNode<K,V> e = b, next; e != null; e = next) {
        // 保存当前节点的next指针（双向链表的next，非树结构的right）
        next = (TreeNode<K,V>)e.next;
        // 【关键】断开原链表引用！
        // 原因：防止残留引用导致内存泄漏，也为后续重建树做准备
        e.next = null;
        // 高低位判断（与链表迁移逻辑完全相同）
        if ((e.hash & bit) == 0) {
            // 低位链表插入（维护双向链表的prev指针）
            // e.prev = loTail：设置当前节点的prev指向原尾节点
            // 若loTail为null（首次插入），则e.prev = null
            if ((e.prev = loTail) == null)
                loHead = e;          // 首次插入：设置头节点
            else
                loTail.next = e;     // 非首次：原尾节点的next指向当前节点
            loTail = e;              // 更新尾指针
            ++lc;                    // 低位计数+1
        } else {
            // 高位链表插入（逻辑同上）
            if ((e.prev = hiTail) == null)
                hiHead = e;
            else
                hiTail.next = e;
            hiTail = e;
            ++hc;                    // 高位计数+1
        }
    }
    // ===== 阶段2：低位链表处理 =====
    if (loHead != null) {
        // 退化判断：节点数 ≤ 6 时退化为普通链表
        // UNTREEIFY_THRESHOLD = 6（定义在HashMap类中）
        if (lc <= UNTREEIFY_THRESHOLD) {
            // untreeify()：将TreeNode链表转换为普通Node链表
            // 过程：遍历每个TreeNode，创建对应的Node对象，丢弃树结构指针
            tab[index] = loHead.untreeify(map);
        } else {
            // 节点数 > 6：保留为TreeNode，准备重建红黑树
            tab[index] = loHead;
            // 优化：仅当高位链表非空时才重建树
            // 原因：若高位为空，说明所有节点都在低位，树结构未被破坏，无需重建
            if (hiHead != null) {
                // treeify()：将TreeNode链表重建为红黑树
                // 过程：按链表顺序逐个插入，每次插入后进行平衡调整
                ((TreeNode<K,V>)loHead).treeify(tab);
            }
        }
    }
    // ===== 阶段3：高位链表处理（逻辑同低位）=====
    if (hiHead != null) {
        if (hc <= UNTREEIFY_THRESHOLD) {
            tab[index + bit] = hiHead.untreeify(map);
        } else {
            tab[index + bit] = hiHead;
            if (loHead != null) {
                ((TreeNode<K,V>)hiHead).treeify(tab);
            }
        }
    }
}