HashMap源码分析

W_Y_Long

已于 2022-08-25 11:51:41 修改

阅读量125

点赞数

文章标签： java 哈希算法数据结构

于 2022-08-25 10:49:13 首次发布

本文链接：https://blog.csdn.net/W_Y_Long/article/details/126519874

版权

简介

Java为数据结构中的映射定义了一个接口java.util.Map，它根据键的hashCode值存储数据，大多数情况下可以直接定位
到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。 HashMap最多只允许一条记录的键为null，允许多条记
录的值为null。HashMap非线程安全，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。如果需要满
足线程安全，可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用ConcurrentHashMap。

内部实现

搞清楚HashMap，首先需要知道HashMap是什么，即它的存储结构-字段；其次弄明白它能干什么，即它的功能实现-方法。

存储结构-字段

从结构实现来讲，HashMap是数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下如所示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D4fyLnfu-1661395649426)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/39ff6d0428a0448b98286b30b8073d36~tplv-k3u1fbpfcp-watermark.image?)]

HashMap内部类Node

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }
    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }
    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;
    }
}

从源码可知，HashMap类中有一个非常重要的字段，就是 Node[] table，即哈希桶数组，明显它是一个Node的数组。
Node是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)。
上图中的每个黑色圆点就是一个Node对象。

HashMap就是使用哈希表来存储的。哈希表为解决冲突，可以采用开放地址法和链地址法等来解决问题，Java中HashMap
采用了链地址法。链地址法，简单来说，就是数组加链表的结合。在每个数组元素上都有一个链表结构，当数据被Hash后，
得到数组下标，把数据放在对应下标元素的链表上。

例如：

执行：map.put(“美团”,“小美”);

系统将调用“美团”这个key的hashCode()方法得到其hashCode 值（该方法适用于每个Java对象），然后再通过Hash算法
的后两步运算（高位运算和取模运算）来定位该键值对的存储位置，有时两个key会定位到相同的位置，表示发生了Hash
碰撞。当然Hash算法计算结果越分散均匀，Hash碰撞的概率就越小，map的存取效率就会越高。

如果哈希桶数组很大，即使较差的Hash算法也会比较分散，如果哈希桶数组数组很小，即使好的Hash算法也会出现较多碰
撞，所以就需要在空间成本和时间成本之间权衡，其实就是在根据实际情况确定哈希桶数组的大小，并在此基础上设计好
的hash算法减少Hash碰撞。

那么通过什么方式来控制map使得Hash碰撞的概率又小，哈希桶数组（Node[] table）占用空间又少呢？

答案就是好的Hash算法和扩容机制。

在理解Hash和扩容流程之前，我们得先了解下HashMap的几个字段。从HashMap的默认构造函数源码可知，构造函数就是对下面几个字段进行初始化，源码如下：

/**
 * The number of key-value mappings contained in this map.
 */
transient int size; // HashMap中实际存在的键值对数量

/**
 * The number of times this HashMap has been structurally modified
 * Structural modifications are those that change the number of mappings in
 * the HashMap or otherwise modify its internal structure (e.g.,
 * rehash).  This field is used to make iterators on Collection-views of
 * the HashMap fail-fast.  (See ConcurrentModificationException).
 */
transient int modCount; // HashMap内部结构发生变化的次数

/**
 * The next size value at which to resize (capacity * load factor).
 */
// (The javadoc description is true upon serialization.
// Additionally, if the table array has not been allocated, this
// field holds the initial array capacity, or zero signifying
// DEFAULT_INITIAL_CAPACITY.)
int threshold; // 所能容纳的key-value对极限

/**
 * The load factor for the hash table.
 */
final float loadFactor; // 负载因子

首先，Node[] table的初始化长度length(默认值是16)，Load factor为负载因子(默认值是0.75)，threshold是HashMap
所能容纳的最大数据量的Node(键值对)个数。threshold = length * Load factor。也就是说，在数组定义好长度之后，
负载因子越大，所能容纳的键值对个数越多。

结合负载因子的定义公式可知，threshold就是在此Load factor和length(数组长度)对应下允许的最大元素数目，超过这
个数目就重新resize(扩容)，扩容后的HashMap容量是之前容量的两倍。默认的负载因子0.75是对空间和时间效率的一个
平衡选择，建议大家不要修改，除非在时间和空间比较特殊的情况下，如果内存空间很多而又对时间效率要求很高，可以
降低负载因子Load factor的值；相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子loadFactor的值，
这个值可以大于1。

size这个字段其实很好理解，就是HashMap中实际存在的键值对数量。注意和table的长度length、容纳最大键值对数量
threshold的区别。而modCount字段主要用来记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败。强调一
点，内部结构发生变化指的是结构发生变化，例如put新键值对，但是某个key对应的value值被覆盖不属于结构变化。

在HashMap中，哈希桶数组table的长度length大小必须为2的n次方(一定是合数)，这是一种非常规的设计，常规的设计是
把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数。Hashtable初始化桶大小为11，就是桶大小设计为素数
的应用（Hashtable扩容后不能保证还是素数）。HashMap采用这种非常规设计，主要是为了在取模和扩容时做优化，同时
为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。

这里存在一个问题，即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会
严重影响HashMap的性能。于是，在JDK1.8版本中，对数据结构做了进一步的优化，引入了红黑树。而当链表长度太长
（默认超过8）时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高HashMap的性能，其中会用到红黑树的插入、
删除、查找等算法。

功能实现-方法

HashMap的内部功能实现很多，这里主要从根据key获取哈希桶数组索引位置、put方法的详细执行、扩容过程三个具有代表性的点深入展开讲解。

根据key获取哈希桶数组索引位置

先看源码：

/*---------------------------------------------------jdk1.8------------------------------------------------------*/
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

/**
* 此处分为两步：
*   h = key.hashCode() 第一步，获取hashCode值
*   h ^ (h >>> 16) 第二步，将hashCode的高16位异或hashCode的低16位来获得一个新的hash值
*   h >>> 16: 将h右移16位
*   h ^ (h >>> 16): ^表示如果是同值取 0、异值取 1
*/
/*---------------------------------------------------jdk1.7------------------------------------------------------*/
static int hash(int h) {
    // 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);
}

对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用hash(Object key)所计算得到的Hash码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，模运算的消耗还是比较大的。

取模运算表现在getNode(int hash, Object key)和putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)方法中，源码如下：

/*
* getNode方法
*/
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) { // (n - 1) & hash为取模运算
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

/**
* putVal方法
*/
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) // (n - 1) & hash为取模运算
        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) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

如上述源码中所示，(n - 1) & hash为取模运算，这里使用的是&而不是%，这是因为当hash值为2的n次方时，&运算比%运算更加高效，这样可以缓解取模运算消耗较大的缺点。根据官方的解释，hash值之所以取hashCode()高16位的值异或低16位的值，是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。

注意：此处的n表示table的长度，也就是HashMap扩容前的大小，默认为16。

JDK1.7与1.8的区别

hash()方法又称扰动函数。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使
用扰动函数之后可以减少碰撞。

jdk1.7中，进行了四次扰动之后获得hash值，通过indexFor()方法，进行取模运算，最终得到索引值。
jdk1.8中，只进行了一次扰动就获得hash值，然后在putVal()、getNode()方法中，都有使用(n - 1) & hash进行取模运
算。

jdk1.8相比较jdk1.7，效率提高了。

分析HashMap的put方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // table是否为null或length是否为0
    if ((tab = table) == null || (n = tab.length) == 0)
        // 调用resize方法进行扩容
        n = (tab = resize()).length;
    // i = (n - 1) & hash 获取hashCode值进行高低16位异或的值再进行取模运算，得到插入的数组索引i，判断tab(i)是否为null
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 如果为null则直接创建新的节点插入该位置
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 如果新插入数据的key与发生冲突的node节点的key相同，则记录下来
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 判断冲突的node的节点是否是红黑树结构
        else if (p instanceof TreeNode)
            // 调用红黑树的插入方法
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 发生冲突的node节点还是链表结构
        else {
            // 遍历链表
            for (int binCount = 0; ; ++binCount) {
                // 如果遍历到链表的末节点，依旧未发现key相同的数据
                if ((e = p.next) == null) {
                    // 在链表的末端创建新节点，插入数据
                    p.next = newNode(hash, key, value, null);
                    // 插入数据后，判断链表的长度是否达到红黑树要求
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        // 转换为红黑树
                        treeifyBin(tab, hash);
                    break;
                }
                // 如果发现新插入的key值与链表已存在的key值相同，记录下来
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        // 判断节点不为null
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            // 如果onlyIfAbsent的值为true，则不替换
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            // 这句是为了LinkedHashMap排序操作，HashMap中无用处。HashMap为无序
            afterNodeAccess(e);
            return oldValue;
        }
    }
    // modCount加一，modCount字段主要用来记录HashMap内部结构发生变化的次数
    ++modCount;
    // 如果新加入元素之后HashMap的长度达到容量的极限，则进行扩容。
    // size是HashMap中实际存在的键值对数量。
    // threshold是HashMap所能容纳的最大数据量的Node(键值对)个数。
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

具体流程图如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A0N5jg7T-1661395649428)(https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7047140159f342f4b43fe8bfab462be3~tplv-k3u1fbpfcp-watermark.image?)]

JDK1.7与1.8的区别

jdk1.7中，HashMap底层使用的数据结构是数组和链表。
jdk1.8中，HashMap底层使用的数据结构是数组、链表和红黑树。默认当链表长度超过8时，就会转换为红黑树。
使用红黑树代替链表的原因是，红黑树查找节点的时间复杂度为O(logn)，而遍历链表所需要的时间复杂度为O(n)，因此为了提高HashMap的效率，在链表过长时会转换为红黑树。

扩容机制

扩容(resize)就是重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组。这些操作都是在HashMap中的resize()方法中实现的。

resize()方法源码如下：

final Node<K,V>[] resize() {
/*----------------------------第一部分，初始化容器----------------------------*/
    // 获取旧的table
    Node<K,V>[] oldTab = table;
    // 获取旧table的实际长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 获取旧的table容量
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 判断旧table长度是否大于0
    if (oldCap > 0) {
        // 判断旧table实际长度是否大于为容量的最大值
        // static final int MAXIMUM_CAPACITY = 1 << 30;
        if (oldCap >= MAXIMUM_CAPACITY) {
            // 将threshold设置为int的最大值
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // << 1操作即地位补0的方式，与 *2 的效果一样且速度更快
        // 判断两倍的旧table实际长度是否会小于容量最大值，旧table的实际长度是否大于等于16
        // static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 新的容器容量为旧容器容量的两倍
            newThr = oldThr << 1; // double threshold
    }
    // 如果hashtable尚未定义，则初始化定义容量以及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"})
        //生成新的newTab来替换之前的oldTable
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
/*----------------------------第二部分，数据替换----------------------------*/
    // 判断旧table中是否有值
    if (oldTab != null) {
        // 遍历旧table
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            // 遍历判断节点是否为空
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                // 判断当前节点是否为最后一个节点
                if (e.next == null)
                    // 重新计算索引值，将node节点放入
                    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;
                        // 利用取模运算计算新的索引值，如果索引值不需要修改，则由loHead链表来保存
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 利用取模运算计算新的索引值，如果索引值需要修改，则由hiHead链表来保存
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 循环结束，如果不需要修改索引位置的node，则直接将loHead保存到newTab[j]中
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 如果需要修改索引位置的node，则直接将hiTail保存到newTab[j + oldCap]中
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

源码解析如下：

第一部分：初始化容器

扩容，就是使用一个新的容器来替换旧的容器。HashMap为了优化取模的速度，让哈希桶的长度必须为2的n次方，所以每
一次扩容都是在原有哈希桶的大小上扩充一倍。

通过：newCap = oldCap << 1; newThr = oldThr << 1;这种位偏移的方式，相当于newCap = oldCap * 2; 但是效率会
更高，在计算机中，位运算的速度更快。

如果哈希桶的容量仍未定义，也会进行数据初始化。

第二部分：使用newTab替换oldTab中的数据

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) { // 计算当前节点的索引，判断为0还是为1
        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) { // 为0则表示索引不变
    loTail.next = null;
    newTab[j] = loHead;
}
if (hiTail != null) { // 为1则新索引 = 原索引 + 原容量
    hiTail.next = null;
    newTab[j + oldCap] = hiHead;
}

jdk1.7旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置。

jdk1.8中，由于哈希桶的长度一定是2的n次方，所以对Node的重新计算索引也就是hash值对length - 1重新取模的索引
值，要么是原索引，要么是原索引+原长度。这主要取决于hash值新增的那一位bit是0还是1。如果是0的话，新索引就还
是原索引；如果是1的话，新索引就是原索引+原长度。所以重新计算索引时根本不需要重新计算它们的位置，只需要判
断新增的那一位bit是0还
是1就可以了，大大优化了效率。

源码中使用 (e.hash & oldCap) == 0 进行判断，为true则依旧是原索引，为false则为原索引+原长度。

jdk1.8中创建了两个链表：loHead和hiHead。
loHead用来存放索引不变的节点；hiHead用来存放索引改变的节点。在while循环结束的时候，进行判断是否为空，就能
将节点存放到对应位置，不需要与JDK1.7一样倒置。

get方法解析

public V get(Object key) {
    Node<K,V> e;
    // 根据key获取hash值，通过hash值获取到key对应的数据，为空则返回null，不为空则返回key对应的数据
    return (e = getNode(hash(key), key)) == null ? null : e.value; 
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 判断table是否为空，表的长度是否小于0，以及索引对应的表数据是否为null
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 判断第一个节点是否为查找的节点
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            // 是，则返回该节点
            return first;
        // 判断节点e是否为末尾节点
        if ((e = first.next) != null) {
            // 判断节点是否为红黑树
            if (first instanceof TreeNode)
                // 通过调用红黑树的api获取对应hash和key的节点
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 如果节点为链表，则遍历链表，直至末尾节点
            do {
                // 找到该节点
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 返回该节点
                    return e;
            } while ((e = e.next) != null);
        }
    }
    // key对应的数据不存在，则返回null
    return null;
}