HashMap 源码详解

前言

在 Java 中，HashMap 是一种常用的数据结构，它实现了 Map 接口，用于存储键值对。在这篇文章中，我们将结合源码分析一下 HashMap 的原理。

HashMap 基本原理

HashMap 的基本原理是使用哈希表来存储键值对，哈希表是一种以键值对为元素的数据结构。在哈希表中，每个元素都有一个关键字，称为键（key），它用于唯一标识该元素，值（value）则是存储在该元素中的数据。

在 HashMap 中，键值对的存储过程可以分为两个步骤：

1. 通过键计算哈希值（hashcode），确定键值对的位置；

2. 如果该位置上已经有键值对存在，则通过比较键的值来确定是否已经存在相同的键值对，如果存在，则更新该键值对的值，否则将该键值对插入到哈希表中。

在 Java 中，每个对象都有一个默认的 hashcode 方法，该方法返回一个 int 类型的哈希值。因此，在 HashMap 中，键的 hashcode 值就是通过键对象的 hashcode 方法计算得出的。

HashMap 源码分析

在 Java 中，HashMap 是一个基于哈希表实现的 Map 接口。下面我们将从 HashMap 的构造函数、put 方法、resize 方法等方面来分析 HashMap 的源码。

构造函数

HashMap 的构造函数有多种重载形式，我们先来看一下最常用的一种构造函数：

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;
    threshold = tableSizeFor(initialCapacity);
}

在该构造函数中，首先进行了参数的校验，然后将传入的负载因子（load factor）和初始容量（initial capacity）分别赋值给了 loadFactor 和 threshold。

其中，load factor 表示负载因子，它是一个浮点数，它指定了哈希表的填充因子。当哈希表中的元素个数达到了哈希表容量的一定比例时，哈希表就会进行扩容操作，以保证哈希表中的元素能够均匀地分布在哈希桶（hash bucket）中。而 threshold 则是哈希表的阈值，它的值是一个 2 的幂，它是在调用 tableSizeFor 方法计算得出的。

put 方法

HashMap 的 put 方法是用于将键值对插入HashMap 中的，它的源码如下所示：

public V put(K key, V value) {
    
    
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    
    
    Node<K,V>[] tab;
    Node<K,V> p;
    int n, i;
    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) // -1 for 1st
                        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;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

put 方法中，首先通过 hash 方法计算键的哈希值，然后调用 putVal 方法将键值对插入到哈希表中。

在 putVal 方法中，首先判断哈希表是否为空，如果为空，则调用 resize 方法创建一个新的哈希表。接着，通过计算键的哈希值得到键值对应该插入的哈希桶的位置，如果该位置上没有元素，则直接插入新的键值对；如果该位置上已经有元素，则需要通过比较键的值来确定是否已经存在相同的键值对，如果存在，则更新该键值对的值，否则将该键值对插入到哈希表中。

需要注意的是，在插入键值对时，如果哈希桶中的元素个数达到了一定的阈值，则需要将该哈希桶转换为红黑树，以提高查找效率。

resize 方法

HashMap 的 resize 方法是用于扩容哈希表的，它的源码如下所示：

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; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {
    
                   // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {
    
    
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    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 {
    
     // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
    
    
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
    
    
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
    
    
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((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 方法中，首先获取旧哈希表的长度和阈值，然后根据旧哈希表的长度计算出新哈希表的长度，新哈希表的长度必须是 2 的幂，并且大于旧哈希表的长度。

接着，通过计算新阈值，判断是否需要将哈希表转换为红黑树。如果不需要转换为红黑树，则将旧哈希表中的元素重新分配到新哈希表中。如果需要转换为红黑树，则将旧哈希桶中的元素转换为红黑树。

需要注意的是，在将元素重新分配到新哈希表中时，需要重新计算键的哈希值和对应的哈希桶的位置，并将元素插入到对应的哈希桶中。

HashMap 的面试题

在面试中，HashMap 是一个常见的考点。以下是几个与 HashMap 相关的面试题：

1. HashMap 和 Hashtable 的区别是什么？

HashMap	Hashtable
线程不安全	线程安全
允许存储 null 键和 null 值	不允许存储 null 键和 null 值
迭代器是 fail-fast 的	迭代器不是 fail-fast 的
初始容量为 16	初始容量为 11
扩容因子为 0.75	扩容因子为 1.0

2. 为什么要重写 hashCode 方法？

hashCode 方法是用于计算对象的哈希值的，它在 HashMap 中起到了关键的作用。如果两个对象的 hashCode 值相同，则它们会被存储在同一个哈希桶中，从而影响 HashMap 的性能。因此，为了避免哈希冲突，我们需要重写 hashCode 方法，使其能够生成尽可能不同的哈希值。

3. HashMap 的哈希冲突是如何处理的？

在 HashMap 中，当两个键的 hashCode 值相同时，它们会被存储在同一个哈希桶中。如果同一个哈希桶中有多个元素，则会通过比较键的值来确定是否已经存在相同的键值对。如果存在相同的键值对，则会更新该键值对的值，否则会将该键值对插入到哈希桶中。

当哈希桶中的元素个数达到一定的阈值时，HashMap 会将该哈希桶转换为红黑树，以提高查找效率。

4.为什么负载因子是 0.75 ?

这个问题是某次面试，面试官问的。可是我怎么回答，都好像没有回答到对方想要的点上。（最后，我反问了对方，也没有得到什么明确的答案）

首先，我认为在负载因子为 0.75 的情况下，哈希表能够充分利用空间，同时也能够保证较低的哈希冲突率。涉及到的数学理论支撑，如下：

假设哈希表中元素个数为 M，哈希桶个数为 N，且每个哈希桶中平均有 k 个元素。当哈希冲突发生时，需要遍历哈希桶中的所有元素才能找到目标元素，因此查找的时间复杂度为 O(k)。根据泊松分布的概率密度函数，哈希冲突的概率可以表示为：

P(k >= 1) = 1 - P(k = 0) = 1 - e^(-α)

其中，e 是自然常数，α 是负载因子。当负载因子为 0.75 时，哈希冲突的概率约为 0.39。因此，在负载因子为 0.75 的情况下，哈希表中元素分布较为均匀，同时也能够保证较低的哈希冲突率，从而保证了哈希表的高效性。

总结

在本文中，我们对 HashMap 进行了分析，介绍了其基本原理和源码实现，同时也回答了一些与 HashMap 相关的面试题。

HashMap 作为一种基于哈希表实现的 Map 接口，它的核心思想是将键值对存储在哈希表中，以便于快速查找和插入。在哈希表中，每个元素都有一个关键字，称为键，它用于唯一标识该元素，值则是存储在该元素中的数据。

在实现 HashMap 时，我们需要考虑一些因素，如哈希冲突、扩容因子等。哈希冲突是指不同的键可能会映射到同一个哈希桶中，这时需要通过比较键的值来确定是否已经存在相同的键值对。当哈希桶中的元素个数达到一定的阈值时，需要将该哈希桶转换为红黑树，以提高查找效率。而扩容因子则是指当哈希表中的元素个数达到哈希表容量的一定比例时，需要进行扩容操作，以保证哈希表中的元素能够均匀地分布在哈希桶中。

在面试中，HashMap 是一个常见的考点，常见的问题包括与 Hashtable 的区别、为什么要重写 hashCode 方法、哈希冲突的处理等。了解这些问题，对于我们掌握 HashMap 的原理和应用都有很大的帮助。

总之，HashMap 是 Java 中一个非常重要的数据结构，它广泛应用于各种场景中。通过深入学习 HashMap 的原理和实现，可以帮助我们更好地应用和理解 HashMap，也可以为我们在面试和工作中更好地使用 HashMap 提供帮助。

最后

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

全套视频资料：

一、面试合集

二、源码解析合集

三、开源框架合集

欢迎大家一键三连支持，若需要文中资料，直接扫描文末CSDN官方认证微信卡片免费领取↓↓↓

PS:群里还设有ChatGPT机器人，可以解答大家在工作上或者是技术上的问题