HashMap 的 put 方法源码分析（JDK 1.8）

一、HashMap 的 put 方法源码分析（JDK 1.8）

以下是 HashMap 的 put 方法的源码（JDK 1.8）：

hash(key) 方法

hash(key) 方法用于计算键的哈希值：

• 如果键为 null，返回 0。

• 否则，返回键的哈希码与高 16 位的异或结果（目的是减少哈希冲突）。

putVal 方法

putVal 方法是 HashMap 的核心方法，用于将键值对插入哈希表中。以下是 putVal 方法的源码：

        final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
            Node<K,V>[] tab; // 哈希表数组
            Node<K,V> p;     // 当前节点
            int n, i;        // n: 哈希表长度; i: 索引位置

            // 如果哈希表为空或长度为 0，进行扩容
            if ((tab = table) == null || (n = tab.length) == 0)
                n = (tab = resize()).length;

            // 计算索引位置，如果该位置为空，直接插入新节点
            if ((p = tab[i = (n - 1) & hash]) == null)
                tab[i] = newNode(hash, key, value, null);
            else {
                Node<K,V> e; // 目标节点
                K k;         // 当前节点的键

                // 检查第一个节点是否匹配
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    e = p;
                // 如果节点是树节点，调用红黑树的插入方法
                else if (p instanceof TreeNode)
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                else {
                    // 遍历链表
                    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 &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                            break;
                        p = e;
                    }
                }

                // 如果找到匹配的节点，更新值并返回旧值
                if (e != null) {
                    V oldValue = e.value;
                    if (!onlyIfAbsent || oldValue == null)
                        e.value = value;
                    afterNodeAccess(e);
                    return oldValue;
                }
            }

            // 修改计数器加 1
            ++modCount;
            // 如果元素数量超过阈值，进行扩容
            if (++size > threshold)
                resize();
            afterNodeInsertion(evict);
            return null;
        }

二、putVal 源码解析

1、初始化哈希表：

• 如果哈希表为空或长度为 0，调用 resize() 方法进行扩容

2、计算索引位置：

• 使用 (n - 1) & hash 计算键的存储位置

• 如果该位置为空，直接插入新节点

3、处理哈希冲突：

• 如果该位置不为空，检查第一个节点是否匹配

• 如果节点是树节点，调用红黑树的插入方法

• 否则，遍历链表，插入新节点或更新值

4、更新值：

• 如果找到匹配的节点，更新值并返回旧值

5、扩容：

• 如果元素数量超过阈值，调用 resize() 方法进行扩容

三、JDK 1.8 中 HashMap 的 resize() 方法源码分析

resize() 是 HashMap 中的一个核心方法，用于在哈希表容量不足时进行扩容。扩容的目的是为了减少哈希冲突，提高 HashMap 的性能。在 JDK 1.8 中，resize() 方法不仅负责扩容，还负责在扩容时重新分配键值对的位置

1、resize() 方法的源码

以下是 HashMap 的 resize() 方法的源码（JDK 1.8）：

        final Node<K,V>[] resize() {
            Node<K,V>[] oldTab = table; // 旧的哈希表
            int oldCap = (oldTab == null) ? 0 : oldTab.length; // 旧容量
            int oldThr = threshold; // 旧阈值
            int newCap, newThr = 0; // 新容量和新阈值

            // 计算新容量和新阈值
            if (oldCap > 0) {
                if (oldCap >= MAXIMUM_CAPACITY) { // 如果旧容量已达到最大值
                    threshold = Integer.MAX_VALUE; // 阈值设置为最大值
                    return oldTab; // 直接返回旧表，不再扩容
                }
                else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && // 新容量为旧容量的 2 倍
                         oldCap >= DEFAULT_INITIAL_CAPACITY) // 如果旧容量大于默认初始容量
                    newThr = oldThr << 1; // 新阈值为旧阈值的 2 倍
            }
            else if (oldThr > 0) // 如果旧阈值大于 0（初始化时指定了容量）
                newCap = oldThr; // 新容量为旧阈值
            else { // 如果旧容量和旧阈值都为 0（默认初始化）
                newCap = DEFAULT_INITIAL_CAPACITY; // 新容量为默认初始容量（16）
                newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 新阈值为默认负载因子 × 默认初始容量
            }

            // 如果新阈值为 0，重新计算
            if (newThr == 0) {
                float ft = (float)newCap * loadFactor; // 新容量 × 负载因子
                newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                          (int)ft : Integer.MAX_VALUE); // 如果未超过最大容量，设置为 ft，否则设置为最大值
            }

            threshold = newThr; // 更新阈值
            @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 创建新表
            table = newTab; // 更新哈希表

            // 如果旧表不为空，重新分配键值对
            if (oldTab != null) {
                for (int j = 0; j < oldCap; ++j) { // 遍历旧表
                    Node<K,V> e;
                    if ((e = oldTab[j]) != null) { // 如果当前桶不为空
                        oldTab[j] = null; // 清空旧桶
                        if (e.next == null) // 如果当前桶只有一个节点
                            newTab[e.hash & (newCap - 1)] = e; // 直接放入新表
                        else if (e instanceof TreeNode) // 如果当前桶是红黑树
                            ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); // 拆分红黑树
                        else { // 如果当前桶是链表
                            Node<K,V> loHead = null, loTail = null; // 低位链表头尾节点
                            Node<K,V> hiHead = null, hiTail = null; // 高位链表头尾节点
                            do {
                                if ((e.hash & oldCap) == 0) { // 如果哈希值的对应位为 0
                                    if (loTail == null) // 如果低位链表为空
                                        loHead = e; // 设置头节点
                                    else
                                        loTail.next = e; // 添加到尾部
                                    loTail = e; // 更新尾节点
                                }
                                else { // 如果哈希值的对应位为 1
                                    if (hiTail == null) // 如果高位链表为空
                                        hiHead = e; // 设置头节点
                                    else
                                        hiTail.next = e; // 添加到尾部
                                    hiTail = e; // 更新尾节点
                                }
                            } while ((e = e.next) != null); // 遍历链表

                            // 将低位链表放入新表的原位置
                            if (loTail != null)
                                loTail.next = null;
                            newTab[j] = loHead;

                            // 将高位链表放入新表的新位置（原位置 + 旧容量）
                            if (hiTail != null)
                                hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }

            return newTab; // 返回新表
        }

四、resize() 方法源码解析

1、计算新容量和新阈值

• 如果旧容量大于 0：

  • 如果旧容量已达到最大值（MAXIMUM_CAPACITY），直接返回旧表，不再扩容

  • 否则，新容量为旧容量的 2 倍，新阈值为旧阈值的 2 倍

• 如果旧容量为 0 但旧阈值大于 0（初始化时指定了容量），新容量为旧阈值

• 如果旧容量和旧阈值都为 0（默认初始化），新容量为默认初始容量（16），新阈值为默认负载因子 × 默认初始容量

2、创建新表

• 根据新容量创建新表（newTab）

• 更新哈希表引用（table = newTab）

3、重新分配键值对

• 遍历旧表的每个桶：

  • 如果当前桶只有一个节点，直接放入新表

  • 如果当前桶是红黑树，调用 split() 方法拆分红黑树

  • 如果当前桶是链表，将链表拆分为低位链表和高位链表：

    • 低位链表：哈希值的对应位为 0，放入新表的原位置

    • 高位链表：哈希值的对应位为 1，放入新表的新位置（原位置 + 旧容量）

4、返回新表

• 返回扩容后的新表

五、resize() 方法的关键点

1、扩容时机：

• 当 HashMap 中的元素数量超过阈值（容量 × 负载因子）时，触发扩容

2、扩容机制：

• 新容量为旧容量的 2 倍

• 新阈值为旧阈值的 2 倍

3、键值对重新分配：

• 通过 (e.hash & oldCap) 判断键值对应该放入低位链表还是高位链表。

• 低位链表放入新表的原位置，高位链表放入新表的新位置（原位置 + 旧容量）

值得注意的是：为了防止java1.7之前元素迁移头插法在多线程是会造成死循环，java1.8+后使用尾插法

4、红黑树拆分：

• 如果桶是红黑树，调用 split() 方法将红黑树拆分为两个链表或红黑树

六、resize() 方法的示例

以下是一个 HashMap 扩容的示例：

七、总结

resize() 是 HashMap 的核心方法之一，负责在容量不足时进行扩容。它的主要逻辑包括：

• 1、计算新容量和新阈值。

• 2、创建新表。

• 3、重新分配键值对。

• 4、返回扩容后的新表。

通过扩容，HashMap 可以减少哈希冲突，提高性能。理解 resize() 方法的实现原理，有助于更好地使用和优化 HashMap