// 偽代碼邏輯
if (++size > threshold)
    resize();

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

// HashMap.resize() 方法片段 - 鏈表遷移
for (int j = 0; j < oldCap; ++j) {          // 遍歷舊數(shù)組每個桶
    Node<K,V> e;
    if ((e = oldTab[j]) != null) {          // 桶非空
        oldTab[j] = null;                   // 清空原桶，便于GC
        if (e.next == null)                 // 單節(jié)點：直接遷移
            newTab[e.hash & (newCap - 1)] = e;
        else if (e instanceof TreeNode)     // 紅黑樹：調(diào)用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;
            // 遍歷原鏈表，逐節(jié)點拆分
            do {
                next = e.next;  // 1. 保存當前節(jié)點的next，防止斷鏈后無法繼續(xù)遍歷
                // 2. 高低位判斷：(hash & oldCap) == 0 ?
                //    oldCap是2的冪（如16=0b10000），此操作等價于判斷hash的第5位是否為0
                //    - 為0：新索引 = 原索引（低位）
                //    - 非0：新索引 = 原索引 + oldCap（高位）
                if ((e.hash & oldCap) == 0) {
                    // ===== 低位鏈表插入（尾插法）=====
                    if (loTail == null)       // 首次插入：設(shè)置頭節(jié)點
                        loHead = e;
                    else                      // 非首次：尾節(jié)點的next指向當前節(jié)點
                        loTail.next = e;
                    loTail = e;               // 更新尾指針為當前節(jié)點
                } else {
                    // ===== 高位鏈表插入（尾插法）=====
                    if (hiTail == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                }
            } while ((e = next) != null);    // 移動到下一個節(jié)點，繼續(xù)遍歷
            // 3. 斷尾操作：必須將兩條鏈表的尾節(jié)點next置為null！
            //    原因：遍歷時未斷開原鏈表引用，若不置null可能形成跨桶環(huán)形引用
            if (loTail != null) {
                loTail.next = null;          // 低位鏈表尾部斷開
                newTab[j] = loHead;          // 放入新數(shù)組的原索引位置
            }
            if (hiTail != null) {
                hiTail.next = null;          // 高位鏈表尾部斷開
                newTab[j + oldCap] = hiHead; // 放入新數(shù)組的原索引+oldCap位置
            }
        }
    }
}

/**
 * 紅黑樹拆分方法（定義在 TreeNode 內(nèi)部類中）
 * 
 * @param map   當前 HashMap 實例
 * @param tab   擴容后的新數(shù)組
 * @param index 原桶在舊數(shù)組中的索引
 * @param bit   舊容量 oldCap（2的冪，如16）
 */
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
    // 1. 獲取當前桶的樹根節(jié)點（同時也是雙向鏈表頭節(jié)點）
    TreeNode<K,V> b = this;
    // 2. 初始化兩條新鏈表的頭尾指針（注意：此時仍是TreeNode，非普通Node）
    TreeNode<K,V> loHead = null, loTail = null;  // 低位鏈表
    TreeNode<K,V> hiHead = null, hiTail = null;  // 高位鏈表
    // 3. 計數(shù)器：記錄高低位鏈表的節(jié)點數(shù)量，用于后續(xù)退化判斷
    int lc = 0, hc = 0;
    // ===== 階段1：按雙向鏈表順序遍歷拆分 =====
    // 注意：這里遍歷的是雙向鏈表（通過next指針），不是紅黑樹結(jié)構(gòu)！
    for (TreeNode<K,V> e = b, next; e != null; e = next) {
        // 保存當前節(jié)點的next指針（雙向鏈表的next，非樹結(jié)構(gòu)的right）
        next = (TreeNode<K,V>)e.next;
        // 【關(guān)鍵】斷開原鏈表引用！
        // 原因：防止殘留引用導(dǎo)致內(nèi)存泄漏，也為后續(xù)重建樹做準備
        e.next = null;
        // 高低位判斷（與鏈表遷移邏輯完全相同）
        if ((e.hash & bit) == 0) {
            // 低位鏈表插入（維護雙向鏈表的prev指針）
            // e.prev = loTail：設(shè)置當前節(jié)點的prev指向原尾節(jié)點
            // 若loTail為null（首次插入），則e.prev = null
            if ((e.prev = loTail) == null)
                loHead = e;          // 首次插入：設(shè)置頭節(jié)點
            else
                loTail.next = e;     // 非首次：原尾節(jié)點的next指向當前節(jié)點
            loTail = e;              // 更新尾指針
            ++lc;                    // 低位計數(shù)+1
        } else {
            // 高位鏈表插入（邏輯同上）
            if ((e.prev = hiTail) == null)
                hiHead = e;
            else
                hiTail.next = e;
            hiTail = e;
            ++hc;                    // 高位計數(shù)+1
        }
    }
    // ===== 階段2：低位鏈表處理 =====
    if (loHead != null) {
        // 退化判斷：節(jié)點數(shù) ≤ 6 時退化為普通鏈表
        // UNTREEIFY_THRESHOLD = 6（定義在HashMap類中）
        if (lc <= UNTREEIFY_THRESHOLD) {
            // untreeify()：將TreeNode鏈表轉(zhuǎn)換為普通Node鏈表
            // 過程：遍歷每個TreeNode，創(chuàng)建對應(yīng)的Node對象，丟棄樹結(jié)構(gòu)指針
            tab[index] = loHead.untreeify(map);
        } else {
            // 節(jié)點數(shù) > 6：保留為TreeNode，準備重建紅黑樹
            tab[index] = loHead;
            // 優(yōu)化：僅當高位鏈表非空時才重建樹
            // 原因：若高位為空，說明所有節(jié)點都在低位，樹結(jié)構(gòu)未被破壞，無需重建
            if (hiHead != null) {
                // treeify()：將TreeNode鏈表重建為紅黑樹
                // 過程：按鏈表順序逐個插入，每次插入后進行平衡調(diào)整
                ((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);
            }
        }
    }
}