HashMap 源码分析详解

Z_9299

已于 2022-09-20 17:14:11 修改

阅读量158

点赞数

分类专栏： Java 文章标签： java 数据结构链表哈希算法

于 2022-08-31 00:11:59 首次发布

本文链接：https://blog.csdn.net/qq_25954461/article/details/126594467

版权

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

数据结构 (1.7、1.8的区别)

JDK1.7 之前，HashMap采用（数组 + 链表）头插法插入元素，在大量并发情况下扩容过程中有可能会形成环形链表，产生死循环问题。

JDK1.8 之后，基于(数组 + 链表 + 红黑树) 数据结构进行实现，链表扩容采用尾插法解决死循环问题，引入红黑树使用二分法进行定位，查询性能较高，并对代码设计进行了优化。

理解HashMap基础【JDK1.8】

查看源码里面几个静态常量定义，可以看出：

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

    /**
     * 这个是默认容量 【16】，必须是 2 的幂。
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**
     * 最大容量，如果一个更高的值由任何一个带参数的构造函数隐式指定时使用，
     * 必须是 2 <= 1<<30 的幂。
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * 构造函数中未指定时使用的负载因子 
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 使用树而不是列表的 bin 计数阈值。
     * 将元素添加到至少具有这么多节点的 bin 时，bin 将转换为树。
     * 该值必须大于 2 并且应该至少为 8，以便与树移除中关于在收缩时转换回普通 bin 的假设相吻合
     */
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * 在调整大小操作期间去树化（拆分）bin 的 bin 计数阈值。
     * 应小于 TREEIFY_THRESHOLD，并且最多 6 以在移除时进行收缩检测。
     */
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * 可对其进行树化的 bin 的最小表容量。
     * 如果 bin 中有太多节点，则调整表的大小。
     * 大小应至少为 4 * 8 以避免调整大小和树化阈值之间的冲突。
     */
    static final int MIN_TREEIFY_CAPACITY = 64;

    .....
}

HashMap继承了AbstractMap类，实现了Map，Cloneable，Serializable接口，那么就具有拷贝、序列化的功能。

以上源码可以理解为，默认容量是 16 ，动态加载因子 0.75f , 当数组长度大于 64 和链表长度大于 8 就会进行树化操作，而当红黑树的节点小于等于 6 后会进行去树化操作。

为何选择链表长度 6【缩容】和 8【扩容】呢？

是基于红黑树的平均查找长度是log(n)，假设长度为8，查找长度为log(8)=3，链表的平均查找长度为n/2，那么 6 / 2 = 3，两者的查找平均长度临界值为 3，所以当长度为 8 才有转换成树的必要。

实现原理

源码内部定义了节点 Node<K,V> 类，它拥有四个属性：

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;

            return o instanceof Map.Entry<?, ?> e
                    && Objects.equals(key, e.getKey())
                    && Objects.equals(value, e.getValue());
        }
    }

hash ：key的哈希值（通过扰动函数计算）

key ：节点的key，类型和定义HashMap时的key相同

value：节点的value，类型和定义HashMap时的value相同

next ：该节点的下一节点，也是一个Node节点，由此产生了一个链表结构

上面每一个Node节点都会指向下一个 next，那么我们只需要记录第一个Node节点，就可以知道整条链的其他节点，所以 HashMap 使用一个数组，记录了每个链表的第一个节点，由此形成了数组 + 链表的数据结构。

扩缩容机制

假设创建一个 HashMap，当 put 存入一个数值时，那么它将会做哪些操作？

// 计算 KEY 的 hashCode 
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}


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) { // 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;
}

1、计算 key 的 hashCode，算出下标位置

HashCode 是使用散列算法计算出来，取值范围是[-2147483648, 2147483647]，但一般容量较小，所以需代码进行了一次扰动计算，(h = key.hashCode()) ^ (h >>> 16) 将哈希值右移16位，再与原哈希值做异或运算，相当于混合原哈希值中的高位和低位，这样可以增大随机性，让数值更小、更加均衡的散列分布，减少数值碰撞的情况

2、判断tab是否位空或者长度为0，如果是无参构造函数则进行初始化扩容操作，初始容量为16 ，如果使用有参构造函数创建HashMap，初始容量则为 指定容量的 2 次方，扩容阈值 = 容量 x 负载因子

static final int tableSizeFor(int cap) {
    int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

3、根据哈希值计算下标，如果没有链表节点，则直接插入数据

4、存在则判断 tab[i] 是否为树节点，是则向树中插入节点，否则向链表中插入数据

5、链表插入数据成功后，判断链表中的节点大于 8 个时，尝试转换为红黑树，treeifyBin(tab, hash) 方法里面再判断数组长度是否大于 64 ，大于则转换为红黑树。

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }

}

6、当容量大于阈值时，进行扩容 resize() ，方法会判断树中节点小于6个，就会从红黑树转换为链表 (去树化)

7、扩容过程中不考虑树化，会遍历Hashmap每个bucket里的链表，每个链表可能会被拆分成两个链表，不需要移动的元素置入loHead为首的链表，需要移动的元素置入hiHead为首的链表，然后分别分配给老的buket和新的buket。loHead链表就不需要重新计算hashCode，这也就是JDK1.8的部分优化点。

源码总结：