Java源代码阅读——HashMap实现原理

最新推荐文章于 2022-10-31 19:23:30 发布

置顶砺晗

最新推荐文章于 2022-10-31 19:23:30 发布

阅读量509

点赞数

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： HashMap实现原理

本文链接：https://blog.csdn.net/xiaowang627/article/details/60144475

Java 专栏收录该内容

24 篇文章

订阅专栏

本文深入探讨了HashMap的工作原理，包括其实现细节、构造函数、indexFor()函数的作用、为什么容量要为2的次幂、为什么不对hashcode()直接使用以及resize()方法的运作机制。

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

一概述

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

二构造函数

static final int DEFAULT_INITIAL_CAPACITY = 16;//默认大小16

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

static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认装填因子0.75

transient Entry<K,V>[] table;

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);

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        init();
    }

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

    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

hash表的装填因子=表中填入记录数/表的长度。
分析第一个构造函数：

int capacity = 1;
while (capacity < initialCapacity)
    capacity <<= 1;

保证capacity的大小为大于且最接近initialCapacity的2的次幂。原因后续讨论。

三 indexFor()函数

static int indexFor(int h, int length) {
     return h & (length-1);
}

采用&运算寻找索引，先看indexFor()的使用：

final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
}

hash()函数：

final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
 }

由上述调用逻辑可以看出，给定一个key寻找它所对应entry的过程为：

（1）计算hash(key)。

（2）计算indexFor(hash(key),table.length),即为该条目在table[]中的索引。

（3）遍历该索引上的链表找到==或equal key的entry返回。

四 capacity为何要是2的次方（个人理解）

（1）当capacity=2的次方时：h&(capacity-1)==h%capacity，例：

h=7,capacity=8 h%capacity=7,h&(7)=0111&0111=0111;

h=9,capacity=8 h%capacity=1,h&(7)=1001&0111=0001;

于是，可用位运算代替模运算大大加快运算速度。

（2）取capacity为2的次方能提高存储空间利用率，减少冲突。例：

h=9,capacity=8   h%capacity=1,h&(7)=1001&0111=0001;

h=8,capacity=8   h%capacity=0,h&(7)=1000&0111=0000;

h=9,capacity=7   h%capacity=2,h&(6)=1001&0110=0000;

h=8,capacity=7   h%capacity=1,h&(6)=1000&0110=0000;

由上可见当capacity为奇数时，capacity-1位偶数，其二进制最低为必为0，与h进行与运算后最低位必为0，意味着只有编号为偶数的index才有可能存储数据，浪费了存储空间，增加冲突概率；而capacity为2的n次方时，capacity-1的二进制最低位为1，进行&运算后最低位为0或1都有可能，不存在上述缺陷。

五为什么不直接用hashcode()（个人理解）

hashcode()为32位，而capacity默认为16位，如果两个对象的hashcode（）后16位相同，与16位的capacity-1进行&后得到相同的结果，产生冲突，所以通过hash（）函数进行处理。

六 resize()

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean rehash = oldAltHashing ^ useAltHashing;
        transfer(newTable, rehash);
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

（1）何时扩容（resize）?

当HashMap中的元素个数超过数组大小*loadFactor时。

（2）如何扩容？

容量变为原来的两倍，然后重新计算每个元素在数组中的位置，这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

七 Fail-Fast机制

HashMap不是线程安全的，如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException异常。判断是否修改了map是通过modCount（修改次数）域，对HashMap内容的修改都将增加这个值，那么在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount。

在迭代过程中，判断modCount和expectedModCount是否相等，如果不相等就表示已经有其他线程修改了Map。

一般来说，存在非同步的并发修改时不可能作出任何的保证。Fail-Fast尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。