强化基础，HashMap源码全角度详细解析

最新推荐文章于 2022-09-13 14:13:06 发布

且听_风吟

最新推荐文章于 2022-09-13 14:13:06 发布

阅读量5.1k

点赞数 42

分类专栏： Java源码｜追本溯源文章标签： hashmap java HashMap源码

本文链接：https://blog.csdn.net/qq_26803795/article/details/104654763

版权

本文全面解析了HashMap的源码，包括其内部数据结构、初始化、新增、删除、查找及遍历等操作。HashMap基于散列算法，采用数组+链表+红黑树实现，允许null键值。文章详细分析了构造方法、负载因子、扩容机制、链表树化条件，以及红黑树拆分和链化的过程，帮助读者深入理解HashMap的工作原理。

摘要由CSDN通过智能技术生成

HashMap源码深度解析

一、重新认识HashMap

什么是HashMap？

HashMap底层基于散列（Hash）算法，采用hash表实现键值对集合，继承了AbstractMap，实现了Map接口。最早出现在jdk1.2，允许null键和null值，null键的哈希值为0。需要注意的是HashMap不保证键值对顺序，同时非线程安全。
长啥样？

散列算法分为散列再探测和拉链式，HashMap采用的是拉链式，并在jdk1.8后使用红黑树优化长度大于等于8的链表。也就是说，目前HashMap底层数据结构为：数组+链表+红黑树。

数据结构如下图：

如上图所示，HashMap的数据结构采用数组和单链表（或者红黑树）组成，在进行增删改查时首先根据要查找元素的hash值定位到元素所在的数组下标（也称为桶），然后再根据这个桶所存储的元素的类型（单个node，单链表或红黑树）来找到该元素。

当单链表长度大于等于8时，转化为红黑树；当红黑树长度小于6时红黑树转化为链表。
HashMap特点
- 可以接受null键和null值，null键的hash值时0；
- 元素无序，可以序列化，线程不安全；
- 添加，查询的时间复杂度基本都是O(1);
- 存储元素时，根据键的hash值找到对应的桶。如果出现不同的对象计算出来的hash值相同，也就是hash冲突。为了解决这个问题，使用单链表存储相同hash值的HashMap，数组中存放的相当于头节点；
- 当单链表长度大于等于8就会转化为红黑树，当红黑树长度小于等于6，就会转化为单链表（为什么是8？后面源码会解释这个问题）

二、知其所以然----撸源码

在进一步了解源码之前，最好对红黑树有一个大致的了解，感兴趣的可以查看：红黑树动图解析

1. 从类注释开始，能够掌握整个HashMap大致框架

首先需要了解一些变量的含义：

//初始容量是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 
//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子默认值0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表长度大于等于8时，链表转化成红黑树
static final int TREEIFY_THRESHOLD = 8;

//红黑树长度小于等于6时，红黑树转化成链表
static final int UNTREEIFY_THRESHOLD = 6;

//容量最小64时才会转会成红黑树
static final int MIN_TREEIFY_CAPACITY = 64;

//用于fail-fast的，记录HashMap结构发生变化(数量变化或rehash)的数目
transient int modCount;

//HashMap 的实际大小，不一定准确(因为当你拿到这个值的时候，可能又发生了变化)
transient int size;

// 阈值，当前HashMap所能容纳键值对数量的最大值，超过这个值，就需要扩容
// 计算方式：
// 阈值大小 = 数组容量 * 负载因子
int threshold;

//存放数据的数组
transient Node<K,V>[] table;
//链表的节点
static class Node<K,V> implements Map.Entry<K,V> {
   }
//红黑树的节点
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V>{
   }

把类注释简单进行翻译和总结如下：

实现 Map 接口，允许 null 值，不同于 HashTable，是线程不安全的；
get和put 的实现达到了常数的时间复杂度，不过要达到好的迭代效果，initialCapacity 不要太高，loadFactor 不要太低；
loadFactor 默认值 0.75，是均衡了时间和空间损耗算出来的值，较高的值会减少空间开销(扩容减少)，但增加了查找成本(hash冲突增加，链表长度变长），不扩容的条件：数组容量> 需要的数组大小 / loadFactor；
如果有很多数据需要储存到 HashMap 中，建议 HashMap 的容量一开始就设置成足够的大小，这样可以防止在put过程中不断的扩容，影响性能；
HashMap 是非线程安全的，为了解决多线程安全问题，我们可以自己在外部加锁，或者通过Collections#synchronizedMap（在每个方法上加上了 synchronized 锁）来实现，注释里还举了个例子：Map m = Collections.synchronizedMap(new HashMap(...));
在迭代过程中，如果 HashMap 的结构被修改，会快速失败。

2. 初始化

2.1、构造方法解析

// 构造方法一：指定初始容量和负载因子
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);
}

// 构造方法二：指定初始容量，此时负载因子使用默认值0.75
public HashMap(int initialCapacity) {
   
  this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
// 构造方法三：无参构造函数，初始容量是16，负载因子0.75，常用
public HashMap() {
   
  this.loadFactor = DEFAULT_LOAD_FACTOR; 
}

// 构造方法四：拷贝传入的Map，并且负载因子是默认值0.75
public HashMap(Map<? extends K, ? extends V> m) {
   
  this.loadFactor = DEFAULT_LOAD_FACTOR;
  putMapEntries(m, false);
}

通过查看上面的源码我们会发现HashMap的构造方法一共有4个，主要是对initialCapacity，loadFactor和threshold进行初始化，并没有涉及到数据结构的初始化，这部分是延迟到在插入数据时候才会进行。

当我们对时间和空间复杂度有要求的时候，可能就会采用第一种传入初始容量和负载因子的构造方式，这两个参数可以计算得出阈值，我们在上一节的类注释的变量的含义里说明了阈值的计算方式有两种，下面让我们深入分析一下，初始容量、负载因子、阈值之间的关系。

2.2、负载因子、阈值深度解析

阈值threshold：

首先默认情况下，初始容量是16，负载因子是0.75，而没有默认的阈值，这是因为数组的初始化是延迟放在了put方法中进行，而阈值也是在扩容的时候根据公式阈值大小 = 数组容量 * 负载因子来计算。

那么为什么在构造方法1和2里，也就是传入了自定义初始容量的情况下，threshold不是按照这个公式计算呢，难得有特殊情况？显然不是的，这样计算出来的阈值是为了在后面扩容的时候用来变换出自定义的capacity，这部分逻辑我们后面查看扩容源码的时候会说明，下面我们需要先看下tableSizeFor方法：

/**
     * Returns a power of two size for the given target capacity.
     */
static final int tableSizeFor(int cap) {
   
  int n = cap - 1;
  将n无符号右移1位，并将结果与右移前的n做按位或操作，结果赋给n；
  n |= n >>> 1;
  n |= n >>> 2;
  n |= n >>> 4;
  n |= n >>> 8;
  n |= n >>> 16;
  中间过程的目的就是使n的二进制数的低位全部变为1，比如10，11变为11，100，101，110，111变为111；
  return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

关于这个tableSizeFor方法可以用一句话来概括，返回大于等于cap的最小2的幂，比如传入的cap是10，那就会返回16；因为2的3次方小于10，只有返回大于且最小的2的4次方，也就是16；关于这个算法，有一篇很好的文章，讲解的很细致，感兴趣的可以看一下：tableSizeFor方法

负载因子loadFactor：

loadFactor反应了HashMap桶数组的使用情况，当我们调低负载因子时，HashMap 所能容纳的键值对数量变少。扩容时，重新将键值对存储新的桶数组里，键的键之间产生的碰撞会下降，链表长度变短。此时，HashMap 的增删改查等操作的效率将会变高，这里是典型的拿空间换时间。相反，如果增加负载因子（负载因子可以大于1），HashMap 所能容纳的键值对数量变多，空间利用率高，但碰撞率也高。这意味着链表长度变长，效率也随之降低，这种情况是拿时间换空间。我们可以根据实际场景来调节负载因子，一般情况默认即可。

3. 新增

整体概括：

首先我们整体上简单概括HashMap的put步骤，首先计算key的hash值，然后定位到这个hash值属于数组的哪个桶，然后判断桶是否为空，如果为空就将键值对存入即可。如果不为空，就根据那个桶的类型，决定是链表添加数据还是红黑树添加数据，最后还要根据key判断是否覆盖。在整个过程中还要时刻判断是否需要扩容，如果需要就要进行扩容操作。

详细流程图：

在网上找了一个详细的流程图，一会分析源码时候可以对照着看：
在这里插入图片描述

3.1、新增源码分析：

public V put(K key, V value) {
   
  // put方法实际上调用了putVal方法
  return putVal(hash(key), key, value, false, true);
}
// putVal方法
// 参数：
// hash ：通过hash算法计算出来的值
// onlyIfAbsent：默认为false，false表示如果key存在就用新值覆盖
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
   
  //n 表示数组的长度，i 为数组索引下标，p 为 i 下标位置的 Node 值
  Node<K,V>[] tab; Node<K,V> p; int n, i;
  //如果数组为空，调用resize初始化（数组被延长到插入新数据时再进行初始化）
  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);
  // 如果当前索引上有值，则表示hash冲突，
  else {
   
    //e是当前节点的临时变量
    Node<K,V> e; K k;
    // 如果key的hash和值都相等，直接把当前下标位置的 Node 值赋值给临时变量
    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) {
   
        // e = p.next 表示从头开始，遍历链表
        // p.next == null 表明 p 是链表的尾节点
        //链表不包含要插入的键值对节点时，则将该节点接入到链表的最后
        if ((e = p.next) == null) {
   
          //e和p.next都是持有对null的引用,即使p.next后来赋予了值只是改变了p.next指向的引用，和e没有关系
          p.next = newNode(hash, key, value, null);
          //新增时，当链表的长度大于等于树化阈值（8）时，调用treeifyBin进行树化
          if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
            treeifyBin(tab, hash);
          break;
        }
        //遍历过程中，发现链表中有元素和新增的元素相等，结束循环
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
          break;
        //更改循环的当前元素，使p再遍历过程中，一直往后移动
        p = e