一文就懂HashMap原理！学不会你来砍我！

Posted 2022-08-28 流楚丶格念

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了一文就懂HashMap原理！学不会你来砍我！相关的知识，希望对你有一定的参考价值。

文章目录

一文就懂HashMap！学不会你来砍我！
1. HashMap 简介
2. HashMap应用
- 2.1 HashMap继承关系
- 2.2 HashMap应用
3. HashMap 源码分析
4. 实际应用

一文就懂HashMap！学不会你来砍我！

首先写这个HashMap的真是很不容易，跟B站上老师学的，然后整理的

上来肯定是先做一个简介了，别着急同志们

1. HashMap 简介

HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null（但是key的位置只能有一个null），此外，HashMap 中的映射不是有序的。

好，我们根据这里的简介看一个入门例子：

package com.hashmap.example;

import java.util.HashMap;

public class StartDemo 
    public static void main(String[] args) 
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("柳岩", 18);
        hashMap.put("杨幂", 28);
        hashMap.put("刘德华", 40);
        // key做null
		hashMap.put(null,33);
        hashMap.put(null,44);
        // value做null
        hashMap.put("玉如梦",null);

        System.out.println(hashMap);

运行结果如下所示：

这里的HashMap我是用的jdk8的，jdk1.7及以前和jdk1.8 及以后的HashMap是有很大区别的：

1.1 jdk1.7与jdk1.8区别

jdk1.7 及之前 HashMap 由 数组 + 链表 组成，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突（两个对象调用的 hashCode 方法计算的哈希值一致导致计算的教组索引值相同）而存在的（“拉链法”解决冲突）。
jdk1.8 及以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（或者红黑树的边界值，默认为 8 ）并且当前数组的长度大于64时，此时此索引位置上的所有数据改为使用红黑树存储。

下面我们说的HashMap都是jdk1.8 及以后的

1.2 链表转化红黑树的条件：

链表转化红黑树的需要满足两个条件：

阈值大于8（阈值：链表上元素个数）
数组长度小于64

将链表转换成红黑树前会判断，即便阈值大于8，但是数组长度小于64，此时并不会将链表变为红黑树，而是选择逬行数组扩容。

这样做的目的是尽量避开红黑树结构。因为数组比较小，这种情况下变为红黑树结构，反而会降低效率，因为红黑树需要逬行左旋，右旋，变色这些操作来保持平衡。同时数组长度小于64时，搜索时间相对要快些。所以结上所述为了提高性能和减少搜索时间，底层阈值大于8并且数组长度大于64时，链表才转换为红黑树，具体可以参考下面的 treeifyBin() 方法。

当然虽然增了红黑树作为底层数据结构，结构变得复杂了，但是阈值大于8并且数组长度大于64时，链表转换为红黑树时，效率也变的更高效。

1.3 小结：

HashMap 特点：

HashMap存储无序的。
键和值位置都可以是 null，但是键位置只能存在一个 null。
键位置是唯一的，是底层的数据结构控制的。
jdk1.8 前数据结构是链表+数组，jdk1.8 之后是链表+数组+红黑树。
阈值（边界值）> 8 并且数组长度大于 64，才将链表转换为红黑树，变为红黑树的目的是为了高效的查询。

2. HashMap 集合底层的数据结构

2. HashMap应用

2.1 HashMap继承关系

HashMap继承关系如下图所示：

解释说明：

Cloneable 空接口，表示可以克隆。创建并返回 HashMap 对象的一个副本。
Serializable 序列化接口。属于标记性接口。HashMap 对象可以被序列化和反序列化。
AbstractMap 父类提供了 Map 实现接口。以最大限度地减少实现此接口所需的工作。

通过上述继承关系，可能会有同学疑惑：AbstractMap is what？HashMap 已经继承了AbstractMap 而 AbstractMap 类实现了Map 接口，那为什么 HashMap 还要在实现 Map 接口呢？同样在 ArrayList 中 LinkedList 中都是这种结构。

首先不用担心，也不用多想！！！我先告诉你，是因为Java创始人写错了。

据 Java 集合框架的创始人 Josh Bloch 描述，这样的写法是一个失误。在 Java 集合框架中，类似这样的写法很多，最幵始写 Java 集合框架的时候，他认为这样写，在某些地方可能是有价值的，直到他意识到错了。显然的，jdk 的维护者，后来不认为这个小小的失误值得去修改，所以就这样保留下来了。

2.2 HashMap应用

HashMap概述与应用可以参考我的另一篇博文：https://blog.csdn.net/weixin_45525272/article/details/125834918

3. HashMap 源码分析

话不多说，先探究一下源码，从中理解下各个函数的原理：

3.1 成员变量

3.1.1 serialVersionUID

首先是序列化版本号：

private static final long serialVersionUID = 362498820763181265L;

它能够保证类在发生合理改动的情况下不会影响对象的反序列化，确保反序列化成功。这个不是HashMap 的特性，这里不赘述了。

3.1.2 DEFAULT_INITIAL_CAPACITY

往下是集合的初始化容量（必须是 2 的 n 次幂）

// 默认的初始容量是16	1 << 4 相当于 1*2的4次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

经过计算：初始容量是16。

那么这就有一个问题了：为什么必须是 2 的 n 次幂？如果输入值不是 2 的幂比如 10 会怎么样?会发生什么？

下面我们来探究一下：

问题：为什么必须是 2 的 n 次幂？如果输入值不是 2 的幂比如 10 不行吗？会发生什么？

首先我们还是要深入源码探究一下，其实HashMap 构造方法还可以指定集合的初始化容量大小：

// 构造一个带指定初始容量和默认负载因子（0.75)的空 HashMap。
HashMap(int initialCapacity)

在源码中我们可以找到对应位置：

根据上述原理我们可以知道，当向 HashMap 中添加一个元素的时候，需要根据 key 的 hash 值，去确定其在数组中的具体位置。HashMap 为了存取高效，减少碰撞，就是要尽量把数据分配均匀，每个链表长度大致相同，这个实现的关键就在把数据存到哪个链表中的算法。

这个算法实际就是取模，hash % length，计算机中直接求余效率不如位移运算。所以源码中做了优化，使用 hash & (length - 1)，而实际上 hash % length 等于 hash & ( length - 1) 的前提是 length 是 2 的 n 次幂。

根据这条定理，例如长度为 8 的时候，3 & (8 - 1) = 3，2 & (8 - 1) = 2，不同位置上，不碰撞。

继续跟进源码，我们发现他调用了另一个构造方法

public HashMap(int initialCapacity, float loadFactor);

前面都是非法的判断，最重要的是最后一句，调用了tableSizeFor方法，然后将返回值给了threshold（容量）

那么我们继续源码，他是这样实现的：

函数说明：当在实例化 HashMap 实例时，如果给定了 initialCapacity，由于 HashMap 的 capacity 必须都是 2 的幂，因此这个方法用于找到大于等于 initialCapacity 的最小的 2 的幂。

/**
* Returns a power of two size for the given target capacity.
*/
static final int tableSizeFor(int cap) 
  int n = cap - 1;
  n |= n >>> 1;
  n |= n >>> 2;
  n |= n >>> 4;
  n |= n >>> 8;
  n |= n >>> 16;
  return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

我们分析一下这个函数的整个流程：

int n = cap - 1;

这里的-1是为了防止 cap 已经是 2 的幂。如果 cap 已经是 2 的幂，又没有这个减 1 操作，则执行完后面的几条无符号操作之后，返回的 capacity 将是这个 cap 的 2 倍。

如果 n 这时为 0 了（经过了cap - 1后），则经过后面的几次无符号右移依然是 0，最后返回的 capacity 是1（最后有个 n + 1 的操作）。
注意：容量最大也就是 32bit 的正数，因此最后 n |= n >>> 16; 最多也就 32 个 1（但是这已经是负数了，在执行 tableSizeFor 之前，对 initialCapacity 做了判断，如果大于MAXIMUM_CAPACITY(2 ^ 30)，则取 MAXIMUM_CAPACITY。如果等于MAXIMUM_CAPACITY，会执行位移操作。所以这里面的位移操作之后，最大 30 个 1，不会大于等于 MAXIMUM_CAPACITY。30 个 1，加 1 后得 2 ^ 30）。

再拿刚才说的初始值为10试一试：：

注意：得到的这个 capacity 却被赋值给了 threshold。

this.threshold = tableSizeFor(initialCapacity);

最后计算得到16，然后把16返回给了threshold，所以如果是容量设置为10的话，他也会自动计算为16。

这里就有同学会问了，threshold不是等于 Capacity*loadFactor吗？

问题：threshold不是等于 Capacity*loadFactor吗？这里为什么直接返回了？

在jdk8以后的构造方法中，并没有对table这个成员变量进行初始化，table的初始化被推迟到了put方法中，在put方法中会对threshold重新计算。

下面看put源码时，你会得到相应的答案。不慌不慌

3.1.3 DEFAULT_LOAD_FACTOR

再往下是默认的负载因子（默认值 0.75）

static final float DEFAULT_LOAD_FACTOR = 0.75f;

3.1.4 MAXIMUM_CAPACITY

集合最大容量：2³⁰

static final int MAXIMUM_CAPACITY = 1 << 30; // 2的30次幂

3.1.5 TREEIFY_THRESHOLD

当链表的值超过8则会转为红黑树（jdk1.8新增）

// 当桶（bucket）上的结点数大于这个值时会转为红黑树
static final int TREEIFY_THRESHOLD = 8;

问题：为什么 Map 桶中结点个数超过 8 才转为红黑树？

8这个阈值定义在HashMap中，针对这个成员变量，在源码的注释中只说明了 8 是 bin（bin就是 bucket 桶）从链表转成树的阈值，但是并没有说明为什么是 8。

在 HashMap 中有一段注释说明：

Because TreeNodes are about twice the size of regular nodes, we use them only when bins
contain enough nodes to warrant use (see TREEIFY_THRESHOLD). And when they become too
small (due to removal or resizing) they are converted back to plain bins.  In usages with
well-distributed user hashCodes, tree bins are rarely used.  Ideally, under random hashCodes, 
the frequency of nodes in bins follows a Poisson distribution 
(http://en.wikipedia.org/wiki/Poisson_distribution) 
with a parameter of about 0.5 on average for the default resizing
threshold of 0.75, although with a large variance because of resizing granularity. Ignoring variance, 
the expected occurrences of list size k are (exp(-0.5) * pow(0.5, k) / factorial(k)). The first values are:

翻译：因为树结点的大小大约是普通结点的两倍，所以我们只在箱子包含足够的结点时才使用树结点(参见TREEIFY_THRESHOLD)。
当它们变得太小（由于删除或调整大小）时，就会被转换回普通的桶。在使用分布良好的用户 hashCode 时，很少使用树箱。
理想情况下，在随机哈希码下，箱子中结点的频率服从泊松分布
(http://en.wikipedia.org/wiki/Poisson_distribution) ，默认调整阈值为0.75，平均参数约为0.5，尽管由 
于调整粒度的差异很大。忽略方差，列表大小k的预朗出现次数是(exp(-0.5) * pow(0.5, k) / factorial(k))。 
第一个值是：

0:    0.60653066
1:    0.30326533
2:    0.07581633
3:    0.01263606
4:    0.00157952
5:    0.00015795
6:    0.00001316
7:    0.00000094
8:    0.00000006
more: less than 1 in ten million

TreeNodes 占用空间是普通 Nodes 的两倍，所以只有当 bin 包含足够多的结点时才会转成 TreeNodes，而是否足够多就是由 TREEIFY_THRESH〇LD 的值决定的。当 bin 中结点数变少时，又会转成普通的 bin。并且我们查看源码的时候发现，链表长度达到 8 就转成红黑树，当长度降到 6 就转成普通 bin。

这样就解释了为什么不是一开始就将其转换为 TreeNodes，而是需要一定结点数才转为 TreeNodes，说白了就是权衡空间和时间。

这段内容还说到：当 hashCode 离散性很好的时候，树型 bin 用到的概率非常小，因为数据均匀分布在每个 bin 中，几乎不会有 bin 中链表长度会达到阈值。但是在随机 hashCode 下，离散性可能会变差，然而 jdk 又不能阻止用户实现这种不好的 hash 算法，因此就可能导致不均匀的数据分布。不理想情况下随机 hashCode 算法下所有 bin 中结点的分布频率会遵循泊松分布，我们可以看到，一个 bin 中链表长度达到 8 个元素的槪率为 0.00000006，几乎是不可能事件。所以，之所以选择 8，不是随便決定的，而是裉据概率统计决定的。甶此可见，发展将近30年的 Java 每一项改动和优化都是非常严谨和科学的。

也就是说：选择 8 因为符合泊松分布，超过 8 的时候，概率已经非常小了，所以我们选择 8 这个数宇。

补充：

Poisson 分布（泊松分布），是一种统计与概率学里常见到的离散[概率分布]。泊松分布的概率函数为：

泊松分布的参数 A 是单位时间（或单位面积）内随机事件的平均发生次数。泊松分布适合于描述单位时间内随机事件发生的次数。

也可以从查找的时间复杂度去解析：
红黑树的平均查找长度是 log(n)，如果长度为 8，平均查找长度为 log(8) = 3，链表的平均查找长度为 n/2，当长度为 8 时，平均查找长虔为 8/2 = 4，这才有转换成树的必要；链表长度如果是小于等于 6， 6/2 = 3，而 log(6) = 2.6，虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短。

3.1.6 UNTREEIFY_THRESHOLD

当链表的值小于 6 则会从红黑树转回链表

// 当桶（bucket）上的结点数小于这个值，树转为链表 
static final int UNTREEIFY_THRESHOLD = 6;

3.1.7 MIN_TREEIFY_CAPACITY

当 Map 里面的数量超过这个值时，表中的桶才能进行树形化，否则桶内元素太多时会扩容，而不是树形化为了避免进行扩容、树形化选择的冲突，这个值不能小于4*TREEIFY_THRESHOLD(8)

// 桶中结构转化为红黑树对应的数组长度最小的值 
static final int MIN_TREEIFY_CAPACITY = 64;

3.1.8 table

table 用来初始化（必须是二的n次幂）(重点)

// 存储元素的数组 
transient Node<K,V>[] table;

在 jdk1.8 中我们了解到 HashMap 是由数组加链表加红黑树来组成的结构，其中 table 就是 HashMap 中的数组，jdk8 之前数组类型是 Entry<K,V> 类型。从 jdk1.8 之后是 Node<K,V> 类型。

其实吧：它也只是换了个名字，都实现了一样的接口：Map.Entry<K,V>。

Map.Entry<K,V>就是负责存储键值对数据的

3.1.9 entrySet

用来存放缓存

// 存放具体元素的集合
transient Set<Map.Entry<K,V>> entrySet;

3.1.10 size

HashMap 中存放元素的个数(重点)

// 存放元素的个数，注意这个不等于数组的长度
 transient int size;

size 为 HashMap 中 K-V 的实时数量，不是数组 table 的长度。

注意：这里的size是实际个数，和容量不一样，比如说：容量为16，里面只存了“1”,1，“2”,2两个元素，那么他的size是2，table 的长度还是16，所以最后size可能会比数组长度大的。

3.1.11 modCount

用来记录 HashMap 的修改次数

// 每次扩容和更改 map 结构的计数器
 transient int modCount;

3.1.12 threshold

用来调整大小下一个容量的值计算方式为（容量*负载因子）

// 临界值 当实际大小（容量*负载因子）超过临界值时，会进行扩容
int threshold;

3.1.13 loadFactor

哈希表的负载因子(重点)

// 负载因子
final float loadFactor;

探究：容量&负载因子

loadFactor 是用来衡量 HashMap 满的程度，表示HashMap的疏密程度，影响 hash 操作到同一个数组位置的概率，计算 HashMap 的实时负载因子的方法为：size/capacity，而不是占用桶的数量去除以 capacity。capacity 是桶的数量，也就是 table 的长度 length。
loadFactor 太大导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散。loadFactor 的默认值为 0.75f 是官方给出的一个比较好的临界值。
当 HashMap 里面容纳的元素已经达到 HashMap 数组长度的 75% 时，表示 HashMap 太挤了，需要扩容，而扩容这个过程涉及到 rehash、复制数据等操作，非常消耗性能。所以开发中尽量减少扩容的次数，可以通过创建 HashMap 集合对象时指定初始容量来尽量避免。
在 HashMap 的构造器中可以定制 loadFactor。

// 构造方法，构造一个带指定初始容量和负载因子的空HashMap
HashMap(int initialCapacity, float loadFactor);

比如下面代码：

HashMap<String, Integer> map = new HashMap<>(16,0.8f);

为什么负载因子设置为0.75，初始化临界值是12？

loadFactor 越趋近于1，那么数组中存放的数据(entry)也就越多，也就越密，也就是会让链表的长度增加，loadFactor 越小，也就是趋近于0，数组中存放的数据(entry)也就越少，也就越稀疏。

如果希望链表尽可能少些，要提前扩容。有的数组空间有可能一直没有存储数据，负载因子尽可能小一些。

举例：

例如：负载因子是0.4。 那么16*0.4--->6 如果数组中满6个空间就扩容会造成数组利用率太低了。
	 负载因子是0.9。 那么16*0.9--->14 那么这样就会导致链表有点多了，导致查找元素效率低。

所以既兼顾数组利用率又考虑链表不要太多，经过大量测试 0.75 是最佳方案。

threshold 计算公式：capacity(数组长度默认16) * loadFactor(负载因子默认0.75)。

这个值是当前已占用数组长度的最大值。当 Size >= threshold 的时候，那么就要考虑对数组的 resize(扩容)，也就是说，这个的意思就是 衡量数组是否需要扩增的一个标准。扩容后的 HashMap 容量是之前容量的两倍。

3.2 构造方法

HashMap 中重要的构造方法，它们分别如下：

3.2.1 HashMap()

构造一个空的HashMap，默认初始容量（16）和默认负载因子（0.75）。

public HashMap() 
   this.loadFactor = DEFAULT_LOAD_FACTOR; // 将默认的负载因子0.75赋值给loadFactor，并没有创建数组

3.2.2 HashMap(int initialCapacity)

构造一个具有指定的初始容量和默认负载因子（0.75）HashMap 。

// 指定“容量大小”的构造函数
public HashMap(int initialCapacity) 
    this(initialCapacity, DEFAULT_LOAD_FACTOR);

3.2.3 HashMap(int initialCapacity, float loadFactor)

构造一个具有指定的初始容量和负载因子的 HashMap。

/*
	 指定“容量大小”和“负载因子”的构造函数
	 initialCapacity：指定的容量
	 loadFactor:指定的负载因子
*/
public HashMap(int initialCapacity, float loadFactor) 
    	// 判断初始化容量initialCapacity是否小于0
        if (initialCapacity < 0)
            // 如果小于0，则抛出非法的参数异常IllegalArgumentException
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
    	// 判断初始化容量initialCapacity是否大于集合的最大容量MAXIMUM_CAPACITY
        if (initialCapacity > MAXIMUM_CAPACITY)
            // 如果超过MAXIMUM_CAPACITY，会将MAXIMUM_CAPACITY赋值给initialCapacity
            initialCapacity = MAXIMUM_CAPACITY;
    	// 判断负载因子loadFactor是否小于等于0或者是否是一个非数值
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            // 如果满足上述其中之一，则抛出非法的参数异常IllegalArgumentException
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
     	// 将指定的负载因子赋值给HashMap成员变量的负载因子loadFactor
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    
	
	// 最后调用了tableSizeFor，来看一下方法实现：
     /*
     	返回比指定初始化容量大的最小的2的n次幂
     */
    static final int tableSizeFor(int cap) 
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

说明：

对于 javathis.threshold = tableSizeFor(initialCapacity); 疑问解答：

tableSizeFor(initialCapacity)判断指定的初始化容量是否是2的n次幂，如果不是那么会变为比指定初始化容量大的最小的2的n次幂。
但是注意，在tableSizeFor方法体内部将计算后的数据返回给调用这里了，并且直接赋值给threshold边界值了。有些人会觉得这里是一个bug，应该这样书写：
this.threshold = tableSizeFor(initialCapacity) * this.loadFactor;
这样才符合threshold的意思（当HashMap的size到达threshold这个阈值时会扩容）。
但是请注意，在jdk8以后的构造方法中，并没有对table这个成员变量进行初始化，table的初始化被推迟到了put方法中，在put方法中会对threshold重新计算。

3.2.4 HashMap(Map<? extends K, ? extends V> m)

包含另一个 “Map” 的构造函数，比如说

package com.hashmap.example;

import java.util.HashMap;
import java.util.*;

public class StartDemo 
    public static void main(String[] args) 
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("柳岩", 18);
        HashMap<String, Integer> map = new HashMap<>(hashMap);
        System.out.println();

此时就会调用这个构造函数，我们来看一下源码：

// 构造一个映射关系与指定 Map 相同的新 HashMap。
public HashMap(Map<? extends K, ? extends V> m) 
    	// 负载因子loadFactor变为默认的负载因子0.75
         this.loadFactor = DEFAULT_LOAD_FACTOR;
         putMapEntries(m, false);

首先它将负载因子loadFactor变为默认的负载因子0.75，

最后调用了 putMapEntries()，好了，这个肯定是重点了，我们跟进一下源码，来看一下方法实现：

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) 
    //获取参数集合的长度
    int s = m.size();
    if (s > 0) 
        //判断参数集合的长度是否大于0，说明大于0
        if (table == null)  // 判断table是否已经初始化
                // 未初始化，s为m的实际元素个数
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);
                // 计算得到的t大于阈值，则初始化阈值
                if (t > threshold)
                    threshold = tableSizeFor(t);
        
        // 已初始化，并且m元素个数大于阈值，进行扩容处理
        else if (s > threshold)
            resize();
        // 将m中的所有元素添加至HashMap中
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) 
            K key = e.getKey(万字长文教你Android组件化从入门到精通，学不会你来砍我！
 一致性哈希算法原理图文详解！学不会接着来砍我！
 一致性哈希算法原理图文详解！学不会接着来砍我！
 Spring Boot 2从入门到入坟 | Web场景开发篇：超硬核两万四千多字，全网最详细源码分析之静态资源配置原理，不是你来砍我
 Java的垃圾回收机制详解——从入门到出土，学不会接着来砍我！
 Java的垃圾回收机制详解——从入门到出土，学不会接着来砍我！