jdk8的HashMap实现

最新推荐文章于 2023-12-02 10:58:21 发布

cwjbeyond

最新推荐文章于 2023-12-02 10:58:21 发布

阅读量251

点赞数

分类专栏： # 容器

本文链接：https://blog.csdn.net/cwj_beyond/article/details/105683555

版权

本文详细介绍了JDK8中HashMap的初始化、put操作和resize过程，特别是resize时如何通过位运算高效地分散元素，以及何时选择resize而不是转换为红黑树。通过对源码的分析，揭示了HashMap的高效性和设计原理。

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

受疫情影响被退隐江湖，赋闲在家，一直996赶太多需求项目和技改了，趁这个机会复习一下java的基础（针对工作中使用的jdk8版本），同时结合这么多年的实战去重新阅读源码。

初始化

阿里的开发规约有一条

【推荐】集合初始化时，指定集合初始值大小。

说明：HashMap 使用HashMap(int initialCapacity) 初始化，如果暂时无法确定集合大小，那么指定默认值（16）即可。

正例：initialCapacity = (需要存储的元素个数 / 负载因子) + 1。注意负载因子（即 loader factor）默认为 0.75，如果暂时无法确定初始值大小，请设置为 16（即默认值）。

反例：HashMap 需要放置1024 个元素，由于没有设置容量初始大小，随着元素不断增加，容量 7 次被迫扩大，resize 需要重建 hash 表。当放置的集合元素个数达千万级别时，不断扩容会严重影响性能。

由于CR时会自动标记不符合规约的代码段，因此让提交了没指定HashMap初始值大小的同学注意一下。废话少说，直接看代码。

    /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and load factor.
     *
     * @param  initialCapacity the initial capacity
     * @param  loadFactor      the load factor
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY) // 大于最大值2^30时，赋值为最大值
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the specified initial
     * capacity and the default load factor (0.75).
     *
     * @param  initialCapacity the initial capacity.
     * @throws IllegalArgumentException if the initial capacity is negative.
     */
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

    /**
     * Returns a power of two size for the given target capacity.
     */
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

这里的tableSizeFor和记忆中的jdk6不同，举个例子分析一下是如何计算得到大于等于入参的最近一个2的N次方。

cap = 129，129 - 1 = 128，即n = 1000 0000

n |= n >>> 1; // 1000 0000 | 0100 0000 = 1100 0000，将第一个1右移1位，或操作得到“11”，后面低位后续会被覆盖，可以忽略

n |= n >>> 2; // 1100 0000 | 0011 0000 = 1111 0000，将复制后的“11”右移2位，或操作得到“1111”

n |= n >>> 4; // 1111 0000 | 0000 1111 = 1111 1111，将复制后的“1111”右移4位，