java-HashMap源码详解

前言：

学习HashMap底层原理，可以帮助我们在日常工作中更好的使用Map数据结构

---

原理分析：

核心结构

• 数组 + 链表 + 红黑树：默认使用数组存储节点，冲突时链表处理，链表过长（≥8）转红黑树（数组长度≥64），树节点过少（≤6）转回链表。

• 关键参数：

  • initialCapacity：初始容量（默认16）。

  • loadFactor：负载因子（默认0.75），决定扩容阈值。

  • threshold：扩容阈值 = capacity * loadFactor。

哈希计算与索引定位

• 扰动函数：(h = key.hashCode()) ^ (h >>> 16)，混合高位与低位，减少冲突。

• 索引计算：index = (n - 1) & hash（等价于取模，但效率更高）。

PUT 流程（源码解析）

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; Node<K,V> p; int n, i;
    // 1. 数组为空则初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // 2. 计算索引位置，若该位置为空则直接插入新节点
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 3. 节点已存在，判断是否为相同key
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 4. 如果是树节点，调用红黑树插入
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 5. 遍历链表
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 链表长度≥8时尝试树化
                    if (binCount >= TREEIFY_THRESHOLD - 1)
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 6. 替换已存在节点的value
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    // 7. 检查是否扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

扩容（resize）机制

• 新容量：旧容量 × 2。

• 数据迁移优化：节点在新数组中的位置为原位置或原位置 + 旧容量（通过 (e.hash & oldCap) == 0 判断）。

 GET 流程

• 计算哈希 → 定位索引 → 遍历链表/树 → 返回匹配的value。

树化与链化

• 树化条件：链表长度 ≥ 8 且数组长度 ≥ 64。

• 链化条件：树节点 ≤ 6。

---

流程图解析：

PUT 操作流程图

graph TD
    A[开始put操作] --> B[计算key的hash值]
    B --> C{数组是否为空}
    C -- 是 --> D[初始化数组]
    C -- 否 --> E[计算索引i]
    D --> E
    E --> F{位置i是否有节点}
    F -- 无 --> G[插入新节点]
    F -- 有 --> H{节点类型}
    H -- 相同key --> I[替换value]
    H -- 树节点 --> J[红黑树插入]
    H -- 链表节点 --> K[遍历链表]
    K --> L{找到相同key?}
    L -- 是 --> I
    L -- 否 --> M[链表末尾插入节点]
    M --> N{链表长度≥8?}
    N -- 是 --> O[尝试树化]
    N -- 否 --> P[结束]
    O --> Q{数组长度≥64?}
    Q -- 是 --> R[转换为红黑树]
    Q -- 否 --> S[仅扩容数组]
    R --> P
    I --> P
    G --> T[检查扩容]
    T --> P
    P --> U[返回旧值或null]

扩容（resize）流程图

graph TD
    A[开始扩容] --> B[计算新容量和阈值]
    B --> C[创建新数组]
    C --> D[遍历旧数组节点]
    D --> E{节点类型}
    E -- 单节点 --> F[计算新位置并插入]
    E -- 链表 --> G[拆分为高低链表]
    G --> H[高低链表插入新数组]
    E -- 红黑树 --> I[拆分为高低树]
    I --> J{节点数≤6?}
    J -- 是 --> K[转换为链表]
    J -- 否 --> L[保持树结构]
    K --> H
    L --> H
    H --> M[完成迁移]
    M --> N[更新阈值和数组]

---

关键源码解析

treeifyBin 方法（树化）

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // 若数组长度 < 64，优先扩容而非树化
    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 {
            // 将普通Node替换为TreeNode
            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);
    }
}

split 方法（拆分树）

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
    TreeNode<K,V> b = this;
    TreeNode<K,V> loHead = null, loTail = null;
    TreeNode<K,V> hiHead = null, hiTail = null;
    int lc = 0, hc = 0;
    // 按bit位拆分高低链表
    for (TreeNode<K,V> e = b, next; e != null; e = next) {
        next = (TreeNode<K,V>)e.next;
        e.next = null;
        if ((e.hash & bit) == 0) {
            if ((e.prev = loTail) == null)
                loHead = e;
            else
                loTail.next = e;
            loTail = e;
            ++lc;
        } else {
            if ((e.prev = hiTail) == null)
                hiHead = e;
            else
                hiTail.next = e;
            hiTail = e;
            ++hc;
        }
    }
    // 处理低位链表
    if (loHead != null) {
        if (lc <= UNTREEIFY_THRESHOLD)
            tab[index] = loHead.untreeify(map);
        else {
            tab[index] = loHead;
            if (hiHead != null)
                loHead.treeify(tab);
        }
    }
    // 处理高位链表（同上）
    // ...
}

总结：

• 哈希冲突：通过链表与红黑树结合解决。

• 性能优化：扰动函数、树化、扩容策略。

• 线程不安全：多线程操作需同步处理。