13_HashMap底层原理详解

许彰午2026-06-04 11:26

HashMap底层原理详解 ------ 从哈希表到红黑树

文章目录

  • [HashMap底层原理详解 ------ 从哈希表到红黑树](#HashMap底层原理详解 —— 从哈希表到红黑树)

前言

HashMap是Java中最常用的集合类之一，几乎每一个Java项目都会用到它。然而，它的底层实现并不简单：数组、链表、红黑树、位运算、扩容机制......面试中关于HashMap的深度问题层出不穷，甚至被戏称为"Java面试第一问"。

为什么HashMap如此受面试官青睐？因为它完美串联了多个重要知识点：数据结构（数组+链表+红黑树的复合结构）、算法（哈希函数与扰动计算）、并发安全（JDK 1.7头插法导致的环形链表死循环）、JVM原理（对象头与hashCode）、以及工程优化（从1.7到1.8的头插法改尾插法、扩容算法优化）。掌握HashMap的底层原理，相当于同时复习了Java基础中最核心的几个领域。本文将从JDK 1.7和JDK 1.8两个版本对比的角度，全面解析HashMap的底层实现原理。

一、什么是哈希表

哈希表（Hash Table）也叫散列表，是一种根据键（Key）直接访问 值（Value）的数据结构。它的核心思想是：通过一个哈希函数将Key映射到数组的某个位置（桶），从而实现O(1)时间复杂度的查询。在理想情况下（没有哈希碰撞），任何数据只需一次计算就能定位到存储位置------这是数据结构性能的天花板。

但现实中有两个问题必须解决：①不同Key可能计算出相同的哈希值（哈希碰撞），需要处理碰撞机制；②数组空间是有限的，需要设计合理的扩容策略来平衡空间和时间的开销。HashMap的精妙之处就在于它用"数组+链表+红黑树"的复合结构同时解决了这两个问题。

复制代码 
     Key → hashCode() → hash → (n-1) & hash → 数组下标
      1. 计算hashCode
      2. 哈希扰动
      3. 定位桶位置

二、HashMap底层数据结构

2.1 JDK 1.7：数组 + 链表

在JDK 1.7中，HashMap由数组 + 单向链表组成：

java 复制代码 
// JDK 1.7 核心数据结构
static class Entry<K, V> implements Map.Entry<K, V> {
    final K key;
    V value;
    Entry<K, V> next;  // 指向下一个节点
    final int hash;
}

transient Entry<K, V>[] table;  // 哈希桶数组

当发生哈希冲突时，新元素插入到链表的头部（头插法）。

2.2 JDK 1.8：数组 + 链表 + 红黑树

JDK 1.8对HashMap进行了重大优化，当链表长度超过8且数组长度 ≥ 64时，链表会树化为红黑树，从而将最坏情况下的查询时间复杂度从O(n)降低到O(log n)。

java 复制代码 
// JDK 1.8 核心数据结构
static class Node<K, V> implements Map.Entry<K, V> {
    final int hash;
    final K key;
    V value;
    Node<K, V> next;
}

// 红黑树节点
static final class TreeNode<K, V> extends LinkedHashMap.Entry<K, V> {
    TreeNode<K, V> parent;
    TreeNode<K, V> left;
    TreeNode<K, V> right;
    TreeNode<K, V> prev;
    boolean red;
}

transient Node<K, V>[] table;

// 关键常量
static final int TREEIFY_THRESHOLD = 8;      // 树化阈值
static final int UNTREEIFY_THRESHOLD = 6;    // 退化阈值
static final int MIN_TREEIFY_CAPACITY = 64;  // 最小树化容量

三、哈希值与索引计算

3.1 hashCode()与扰动函数

hashCode()是Object类的方法，返回一个int值。HashMap不直接使用hashCode作为哈希值，而是通过扰动函数 增加散列性。这里有一个容易被忽略的关键点：hashCode是一个32位的int值，但实际数组长度通常远小于2^32（比如初始只有16），如果直接使用hashCode的低几位作为索引，高位的特征就完全浪费了。扰动函数的目的就是让高位也"参与"索引计算，让数据分布更均匀，从而降低哈希碰撞概率。

java 复制代码 
// JDK 1.7 ------ 多次扰动
static int hash(int h) {
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

// JDK 1.8 ------ 一次扰动（更高效）
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

JDK 1.8将高16位和低16位做异或操作，让高位也参与索引计算，减少哈希碰撞。这个设计非常精妙。

3.2 索引定位

定位桶位置的代码始终是：(n - 1) & hash，其中n是数组长度（始终为2的幂）。

java 复制代码 
// n 是 2 的幂次方时，(n-1) & hash 等价于 hash % n，但位运算更快
// 例如：n = 16 (0b10000)
//      n-1 = 15 (0b01111)
//      hash & 15 只取后4位，结果在0~15之间

3.3 为什么数组长度必须是2的幂

这是HashMap设计中最容易被忽视的细节之一。为什么要规定长度是2的幂？有两个核心原因：

原因一：位运算替代取模 。当n是2的幂时，(n - 1) & hash等价于hash % n，但位运算的速度远快于取模运算。在HashMap这种高频使用的数据结构中，每次put/get都省下一次取模，积累起来就是可观的性能提升。

原因二：均匀分布 。如果n不是2的幂（比如15），n-1的二进制中某些位会是0（15-1=14=1110），这意味着hash中某些位的特征被"屏蔽"了，导致某些桶位置永远分配不到元素，哈希碰撞概率增大。而2的幂-1的二进制全是1（16-1=15=1111），hash的所有位都能参与索引计算，分布最均匀。

java 复制代码 
public class PowerOfTwo {
    public static void main(String[] args) {
        int tableSize = 16;  // 2^4
        int hash1 = 33;
        int hash2 = 49;

        // (n-1) & hash 可以均匀分布
        System.out.println((tableSize - 1) & hash1);  // 1
        System.out.println((tableSize - 1) & hash2);  // 1

        // 如果n不是2的幂，比如15
        // 15的二进制是1111，与运算会导致某些位始终为0，分布不均匀
        // 而且取模运算 hash % n 效率远低于位运算
    }
}

四、put方法全流程解析

以下是JDK 1.8中put方法的完整流程：

java 复制代码 
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);
        
        // 步骤5：否则是链表，遍历链表
        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;
                }
                // 找到了相同的key，更新
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        
        // 步骤6：存在旧值，更新
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            return oldValue;
        }
    }
    
    // 步骤7：大小自增，判断是否需要扩容
    if (++size > threshold)
        resize();
    
    return null;
}

重点变化 ：JDK 1.7使用头插法 ，JDK 1.8改为尾插法 ------这是为了解决并发扩容时头插法可能造成环形链表导致死循环的问题。这个bug曾经是Java社区最大的"翻车现场"之一：在多线程环境下对同一个HashMap执行put操作，扩容时多线程同时对链表进行头插法操作，可能导致节点之间形成环形引用，造成后续get操作进入死循环CPU飙到100%。理解这个问题的根因，比记住"HashMap线程不安全"这句话重要得多。

五、扩容机制详解

5.1 resize()的核心逻辑

java 复制代码 
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
                 && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1;  // 阈值也翻倍
    }
    // ... 省略边界情况处理
    
    threshold = newThr;
    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
                    // 链表：拆分为高低位两个链表
                    // 利用了扩容后新增的那一位（oldCap）是0还是1来决定位置
                    // ... 详见下节
            }
        }
    }
    return newTab;
}

5.2 扩容时的巧妙设计

扩容时，不需要像JDK 1.7那样重新计算hash，而是利用hash & oldCap来判断：

java 复制代码 
// 核心思想：扩容后，原位置是 j 或者 j + oldCap
// 因为新数组长度 = 旧长度 * 2
// 索引 = hash & (newCap - 1)
// 由于newCap-1比oldCap-1多了一个最高位
// 所以只需判断 hash 在 oldCap 那一位是 0 还是 1

// 示例：
//   hash = 18  (0b10010)
//   oldCap = 16 (0b10000)
//   hash & oldCap = 18 & 16 = 16 → 不为0，新位置 = 2 + 16 = 18
//
//   hash = 2   (0b00010)
//   oldCap = 16 (0b10000)
//   hash & oldCap = 2 & 16 = 0 → 为0，新位置 = 2（保持不变）

六、JDK 1.7 vs JDK 1.8 全面对比

对比维度 JDK 1.7 JDK 1.8
数据结构 数组 + 链表 数组 + 链表 + 红黑树
插入方式 头插法 尾插法
哈希算法 4次位运算 + 5次异或 1次位运算 + 1次异或
扩容条件 size >= threshold 同
扩容迁移 重新计算每个元素的hash 利用hash & oldCap优化
初始化时机 inflateTable()时 延迟到第一次put
并发死链 存在（头插法导致环形链表） 不存在（改为尾插法）

七、常见问题与最佳实践

7.1 为什么HashMap线程不安全

java 复制代码 
public class HashMapThreadUnsafe {
    public static void main(String[] args) throws InterruptedException {
        Map<String, Integer> unsafeMap = new HashMap<>();
        
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                unsafeMap.put("key" + i, i);
            }
        });
        
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                unsafeMap.put("key" + i, i);
            }
        });
        
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        
        // 结果可能不是10000，甚至程序卡死（JDK 1.7环形链表）
        System.out.println("size = " + unsafeMap.size());
    }
}

7.2 合理设置初始容量

java 复制代码 
// 如果已知要存储约100个元素
// 考虑负载因子的影响：100 / 0.75 ≈ 133.3
// 建议初始容量设置为 128 或 256（2的幂）
Map<String, String> map = new HashMap<>(128);

// 如果初始容量设为100，HashMap会自动调整到128（最近的2的幂）

7.3 自定义对象作为Key

使用自定义对象作为HashMap的Key时，必须重写hashCode()和equals()方法：

java 复制代码 
public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

// 使用示例
public class PersonKeyDemo {
    public static void main(String[] args) {
        Map<Person, String> map = new HashMap<>();
        Person p1 = new Person("张三", 25);
        map.put(p1, "工程师");
        
        Person p2 = new Person("张三", 25);
        // 因为重写了equals和hashCode，可以正确获取到值
        System.out.println(map.get(p2));  // 工程师
    }
}

总结

HashMap是Java集合框架中最精妙的设计之一。从JDK 1.7到1.8的演进，体现了工程上对性能和安全的极致追求------用红黑树优化极端情况下的链表性能（从O(n)到O(log n)），用尾插法消除并发死链隐患，用位运算加速索引计算和扩容迁移（JDK 1.7需要重新计算hash，1.8只需判断新增位的值）。

回顾本文的核心知识点：

  • 数据结构演进：数组+链表 → 数组+链表+红黑树。树化阈值8和退化阈值6之间有2的缓冲区间，避免反复树化/退化的性能抖动。
  • 哈希与索引 ：hash = hashCode() ^ (h >>> 16)让高位参与索引计算；(n-1) & hash替换取模运算，因为数组长度固定为2的幂时位运算等价于取模且快得多。
  • 扩容机制 ：容量翻倍，负载因子0.75是空间与时间的最佳平衡点。扩容时利用hash & oldCap判断新位置，避免了重新计算hash。
  • 线程安全：HashMap本身线程不安全，JDK 1.7头插法的环形链表是经典bug。多线程场景应使用ConcurrentHashMap。

理解HashMap的底层原理，不仅能帮助你在面试中游刃有余，更重要的是能在日常开发中更好地使用它，比如合理设置初始容量、选择正确的Key类型等。正如一位资深工程师所说："把HashMap吃透了，Java就算入门了一大半。"

✅ 亮点总结

  • 数组+链表+红黑树的复合结构：JDK 1.8用红黑树替代长链表（阈值8），将get操作从O(n)优化到O(log n)，是经典的数据结构组合设计
  • hash()扰动函数的精巧设计：hashCode高16位与低16位异或，让高位特征也参与索引计算，减少哈希碰撞------一行代码背后的算法智慧
  • put()方法的完整流程推导：先计算hash→再确定桶位置→有碰撞则判断是树还是链表→按各自方式插入→检查是否需要扩容，步骤清晰
  • JDK 1.7头插法到1.8尾插法的演进：头插法在多线程rehash时可能造成环形链表导致死循环，尾插法彻底根治------工程迭代的经典案例
  • 扩容机制的三个关键参数：初始容量16、负载因子0.75（空间与时间的平衡点）、2倍扩容+高位迁移bit位运算，一次讲清扩容的完整过程

适用场景

  • 实现本地缓存功能（如LRU Cache），利用HashMap的快速存取特性，配合LinkedHashMap实现按访问顺序淘汰
  • 使用自定义对象作为Key时（如Person），必须同时重写hashCode()和equals()，确保逻辑相等的对象能正确存取
  • 预先知道要存储的元素数量时，用new HashMap<>(expectedSize / 0.75 + 1)设置初始容量，避免频繁扩容影响性能

扩展方向

  • 泛型 ：HashMap <K, V>的类型参数机制，理解泛型擦除和通配符，推荐阅读 14_Java泛型完全指南
  • ConcurrentHashMap：学习JDK 1.7的分段锁（Segment）到1.8的CAS+synchronized演进，理解高并发下的线程安全设计
  • LinkedHashMap与LRU实现 ：利用LinkedHashMap的accessOrder参数，一行代码实现LRU缓存，是面试和实际开发的高频技能

下一篇：14_Java泛型完全指南

相关推荐
GIOTTO情1 小时前
基于 NLP 情感加权算法的智能舆情处置系统架构与落地实现
人工智能·算法·自然语言处理
无风听海1 小时前
PKCE 的 S256 算法深度剖析：从协议设计到密码学原理
javascript·网络·算法·密码学
凌波粒1 小时前
LeetCode--530.二叉搜索树的最小绝对差（二叉树）
算法·leetcode·职场和发展
sali-tec1 小时前
C# 基于OpenCv的视觉工作流-章82-毛刺检测
图像处理·人工智能·opencv·算法·计算机视觉
恒想进步1 小时前
leetcode202.快乐数
算法
8Qi82 小时前
LeetCode 208：实现 Trie（前缀树）—— Java 题解 ✅
java·算法·leetcode·二叉树·tire树
吴可可1232 小时前
CAD2004二次开发C#可行性解析
算法
字节高级特工2 小时前
C++11(二) 革新：引用折叠与lambda表达式
java·开发语言·c++·算法
碎碎念_4922 小时前
”二分“高频题型总结：最小最大值、最大最小值、满足条件最小 / 最大
算法·二分
热门推荐
012026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf02GitHub 镜像站点03【AI】2026 年具身智能模型和世界模型总结04Codex 下载安装指南：Windows 和 macOS 官方版下载05Codex 桌面端更新后 Chrome 插件和 Computer Use 不可用，怎么排查和修复06【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法07CC-Switch 下载、安装与使用配置指南【2026.5.29】08裂开！ChatGPT 居然开始要手机号验证，附详细解决方法09Codex 接入 DeepSeek API 完整配置文档10CC-Switch & Claude 基于 Linux 服务器安装使用指南