HashMap底层代码学习

最新推荐文章于 2024-03-16 21:04:24 发布

原创最新推荐文章于 2024-03-16 21:04:24 发布 · 325 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#HashMap

Java 专栏收录该内容

46 篇文章

订阅专栏

本文深入探讨了HashMap的内部工作原理，包括Put方法的哈希映射和处理冲突的链表方式，Get方法的查找机制，初始默认长度，以及HashMap的构造方法。文章强调了长度为2的幂对哈希算法均匀分布的重要性，并介绍了扩容（resize）的条件和策略。HashMap内部使用的静态嵌套类Node用于存储键值对，形成链表结构以解决冲突。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

HashMap底层源码学习

前述

最近在微信工作号上看到一篇好文章，忍不住推荐一波，供大家学习，我结合文章内容再自己去翻了一翻源码，学习一下HashMap。

众所周知，HashMap是一个用于存储Key-Value键值对的集合，并且是线程不安全的，其中每一个键值对也叫做Entry。这些个键值对（Entry）分散存储在一个名为 table 的数组当中，该数组存储的是 Node<K, V>类型数据，实际上这个类是HashMap中实现了 Map.Entry<K, V>接口的静态嵌套类，而这个数组就是HashMap的主干。

HashMap数组每一个元素的初始值都是Null。

这里写图片描述

对于HashMap，我们最常使用的是两个方法：Get 和 Put。

Put方法的原理

调用Put方法的时候发生了什么呢？

比如调用 hashMap.put(“apple”, 0) ，插入一个Key为“apple”的元素。这时候我们需要利用一个哈希函数来确定Entry的插入位置（index）：

index = Hash（“apple”）

假定最后计算出的index是2，那么结果如下：

这里写图片描述

但是，因为HashMap的长度是有限的，当插入的Entry越来越多时，再完美的Hash函数也难免会出现index冲突的情况。比如下面这样：

这里写图片描述

这时候该怎么办呢？我们可以利用链表来解决。

HashMap数组的每一个元素不止是一个Entry对象，也是一个链表的头节点。每一个Entry对象通过Next指针指向它的下一个Entry节点。当新来的Entry映射到冲突的数组位置时，只需要插入到对应的链表即可：

这里写图片描述

需要注意的是，新来的Entry节点插入链表时，使用的是“头插法”。至于为什么不插入链表尾部，后面会有解释。

Get方法的原理

使用Get方法根据Key来查找Value的时候，发生了什么呢？

首先会把输入的Key做一次Hash映射，得到对应的index：

index = Hash（“apple”）

由于刚才所说的Hash冲突，同一个位置有可能匹配到多个Entry，这时候就需要顺着对应链表的头节点，一个一个向下来查找。假设我们要查找的Key是“apple”：

这里写图片描述

第一步，我们查看的是头节点Entry6，Entry6的Key是banana，显然不是我们要找的结果。

第二步，我们查看的是Next节点Entry1，Entry1的Key是apple，正是我们要找的结果。

之所以把Entry6放在头节点，是因为HashMap的发明者认为，后插入的Entry被查找的可能性更大。

默认初始长度

HashMap的默认初始长度为16，并且每次自动扩展或是手动初始化时，长度必须是2的幂，之所以选择16，是为了服务于从key到index的Hash的算法。

之前说过，从key映射到HashMap数组的对应位置，会用到一个Hash函数：

index = Hash（“apple”）

如何实现一个尽量均匀分布的Hash函数呢？我们通过利用Key的HashCode值来做某种运算。为了实现高效的Hash算法，HashMap的发明者采用了位运算的方法。

如何进行位运算呢？有如下的公式（Length是HashMap的长度）：

index = HashCode（Key） & （Length - 1）

下面我们以值为“book”的Key来演示整个过程：

1.计算book的hashcode，结果为十进制的3029737，二进制的101110001110101110 1001。

2.假定HashMap长度是默认的16，计算Length-1的结果为十进制的15，二进制的1111。

3.把以上两个结果做与运算，101110001110101110 1001 & 1111 = 1001，十进制是9，所以 index=9。

可以说，Hash算法最终得到的index结果，完全取决于Key的Hashcode值的最后几位。

这样做不但效果上等同于取模，而且还大大提高了性能。至于为什么采用16，我们可以试试其他长度会出什么问题。

假设HashMap的长度是10，重复刚才的运算步骤：

这里写图片描述

单独看这个结果，表面上并没有问题。我们再来尝试一个新的HashCode 101110001110101110 1011 ：

这里写图片描述

让我们再换一个HashCode 101110001110101110 1111 试试：

这里写图片描述

是的，虽然HashCode的倒数第二第三位从0变成了1，但是运算的结果都是1001。也就是说，当HashMap长度为10的时候，有些index结果的出现几率会更大，而有些index结果永远不会出现（比如0111）！

这样，显然不符合Hash算法均匀分布的原则。

反观长度16或者其他2的幂，Length-1的值是所有二进制位全为1，这种情况下，index的结果等同于HashCode后几位的值。只要输入的HashCode本身分布均匀，Hash算法的结果就是均匀的。

HashMap的构造方法

在HashMap 无参构造方法的注释是这样写的：

Constructs an empty HashMap with the default initial capacity(16) and the default load factor (0.75).

也就是说，构造一个空的 HashMap 会使用默认的初始容量（16）和一个默认的加载因子（0.75），那么这个加载因子又是什么呢？待我们一起来探讨！HashMap有四种构造方法：

第一种构造方法：无参的

第二种构造方法：用一个已有的Map来构造此Map，并且加载因子置为默认加载因子（0.75）

第三种构造方法：给定一个初始容量，它再自动设置默认的加载因子（0.75）

public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

实际上，这里还是调用了下一种构造方法

第四种构造方法：指定初始容量和加载因子

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}

这里面先对参数进行了合法性检查，加载因子的赋值，还有一个重要的一点就是 threshold 变量存储的是极限值（也可以叫阈值），源码中对极限值的描述是这样的：

The next size value at which to resize (capacity * load factor)

这就是当我们数组容量到达一定极限时，需要扩容了。

上面的tableSizeFor()方法根据传来的参数，返回的数值始终是2的整数次幂（如果想知道怎么回事，可以看我的另一篇关于位运算的博客），这也正对应我们上面的说法。这里指定的容量到后面初始化时也还不是用这个容量，到后面再讲到。

扩容（resize）

接着上面，那我们就要讲到扩容了。首先，扩容发生在什么时候？那当然是在进行 put 操作的时候啊！由于 put() 方法代码有些长，我就不插源码了，可以自己查看一下。

在进行 put 操作时，如果数组是空的或者长度值为0，此处要进行扩容；或者是数组的键值对元素到达了极限值，也是需要扩容了。

扩容方式分类：

如果该数组不空，已经有元素了，那么数组按原来的容量（capacity）两倍的扩容，并且极限值也相对原来的乘以2。
如果数组为空（null）或者长度为零，并且使用的是默认的无参构造方法来创建HashMap对象的，那么，使用 DEFAULT_INITIAL_CAPACITY（16）来创建数组，并使用 DEFAULT_LOAD_FACTOR （默认的加载因子：0.75）来初始化极限值（阈值）。
如果数组为空（null）或者长度为零，使用的是有参构造方法来初始化HashMap对象的，是另一种情况，因为我们在调用有参构造方法时，就已经会根据指定的容量计算出一个阈值（该阈值是2的整数次幂，大于或等于你指定的容量），而此时，我们将使用这个阈值作为指定长度来创建数组（所以我在上面说你指定的容量也不是到时候真正创建数组的容量），并且阈值赋值为此时的数组容量再乘以加载因子（如果你没有指定加载因子，那么使用默认的）。

静态嵌套类 Node<K, V>

如我们上面所说，此静态嵌套类实现了 Map.Entry<K, V>接口，正是数组当中存储的数据类型。

该类中定义了 key，value等属性，其中还有一个成员变量就是：Node<K,V> next，我们能发现，这是一个链表的结构，我们上面说过，每一个元素都维护着一个 hashCode 值相同而导致索引值相同的链表。

该类还重写了 equals() 方法，用来查重，避免插入相同的完全键值对。

public final boolean equals(Object o) {
    if (o == this)
        return true;
    if (o instanceof Map.Entry) {
        Map.Entry<?,?> e = (Map.Entry<?,?>)o;
        if (Objects.equals(key, e.getKey()) &&
            Objects.equals(value, e.getValue()))
            return true;
    }
    return false;
}