HashMap——如何保证容量为2的整数次幂？

已于 2022-01-22 15:32:44 修改
阅读量1.2k 收藏
点赞数 6
文章标签： java 散列表 hashmap 集合
于 2022-01-22 15:18:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhy1379/article/details/122637815
版权

先来看一下HashMap内部元素存放的容器——成员变量table的定义

    /**
     * The table, initialized on first use, and resized as
     * necessary. When allocated, length is always a power of two.
     * (We also tolerate length zero in some operations to allow
     * bootstrapping mechanics that are currently not needed.)
     */
    transient Node<K, V>[] table;

When allocated, length is always a power of two.
翻译过来：长度必须是2的整数次幂

HashMap的容量需要保证为2的整数次幂，但是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)
            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);
    }

如果使用者传入的不是2的整数次幂，比如10；HashMap如何保证容量为2的整数次幂呢？
先测试一下传入一个非2的整数次幂的容量初始化HashMap后的容量：

    @Test
    public void testCapacity() {
        HashMap<String, String> map = new HashMap<>(5);
        // HashMap在添加第一个元素时初始化，所以需要put一个元素，不然反射获取到空数组，会报空指针异常
        map.put("","");
        System.out.println("通过反射获取到的HashMap容量为：" + getHashMapCapacity(map));
    }


    /**
     * 通过反射机制获取 HashMap 的容量
     */
    public static int getHashMapCapacity(HashMap<?,?> map) {
        Class<HashMap> hashMapClass = HashMap.class;
        try {
            Field field = hashMapClass.getDeclaredField("table");
            field.setAccessible(true);
            Object[] objects = (Object[])field.get(map);
            return objects.length;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
            return -1;
        }
    }

输出：

通过反射获取到的HashMap容量为：8

Process finished with exit code 0

传入5，初始化的容量是8；传入10，初始化的容量是16…
分析一下这个流程：
上面代码中使用的是这个构造：

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

这个构造调用的另一个带加载因子的构造（阅读源码，会发现很多这样的写法）：

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

这里对容量与加载因子的边界做了一系列判断（逻辑比较简单，并且不是本文重点），这个先不考虑；来看一下本文重点：

        this.threshold = tableSizeFor(initialCapacity);

这里调用了一个tableSizeFor方法，传入了初始化容量，所以我们来看一下这个方法：

    /**
     * Returns a power of two size for the given target capacity.
     * 返回大于输入参数且最近的2的整数次幂的数
     *      先让 n = cap-1;
     *      假设 n的二进制格式为 0{x}1(0|1){m}  或  0...(x个0)1*...(m个 任意二进制数字)
     *      正则表达式版本：将 0{x}1(0|1){m}
     *              转变为：0{x}1{m+1}
     *              然后返回 n+1 ：0{x-1}10{m+1}
     *      即：将0...(x个0)1*...(m个任意二进制数字)
     *          转变为 0...(x个0)1...(m+1个1)
     *          然后返回 n+1 ：0...(x-1个0)10...(m+1个0)
     *
     *      举个例子，cap = 10；n = 9 = 0000 0000 0000 1001
     *      需要将 n 转变为 0000 0000 0000 1111
     *      然后return = n+1 = 0000 0000 0001 0000 = 16
     *
     *      先让 n = cap-1；是因为当cap已经是2的n次幂的时候，返回值时cap而不是2 * cap
     *
     *      原理：
     *      0|0=0; 0|1=1; 1|1=1; 1|0=1;   >>>n 代表将二进制数右移n位，前面补0，后面超出的直接省略
     *      假设n = cap - 1 = 0...1*...(后面有m位)      注：n最多为32位，为1的最高位后面有m位数
     *      n |= n >>> 1       n = 0...11*...(后面有m-1位)
     *      n |= n >>> 2       n = 0...1111*...(后面有m-3位)
     *      n |= n >>> 4       n = 0...1111 1111*...(后面有m-7位)
     *      n |= n >>> 8       n = 0...1111 1111 1111 1111*...(后面有m-15位)
     *      n |= n >>> 16      n = 0...1111 1111 1111 1111 1111 1111 1111 1111*...(后面有m-31位)
     *      注：n最多为32位(int类型 4 字节 32位)，为1的最高位后面有m个未知数，当>>>右移后，m - x的值小于0代表后面m - x的位都被移出了。忽略
     *      然后返回 n + 1 = 0..10...   只有一位为1,1后面是m+1个0  就保证了为2的n此幂
     */

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

这个方法的的作用就是返回>=参数的最小2的整数次幂，即转换为二进制后，有且只有一位为1；
输入cap，用n保存cap减一；经过下面一系列操作，将n转换为大于n的最小2的n此幂-1的形式（即：前面全是0，后面全是1），再将n加一，就得到了2的整数次幂。这一些操作就是：

        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;

考虑n的正常范围：
我们把n（32位）表示成0{32-x-1}1(0|1){x}（{x}表示前面的数字出现x次，这个表达式表示一个前面全是0的1后面有x个位，这个数共32位）：

操作操作后n的值，后面x-m中m代表溢出的位数,先溢出不确定为1还是为0的，再溢出已经确定为1的；如果x-m为负，则代表已经溢出m-x个已经确定为1的位
初始值0{32-x-1}1(0|1){x}
n |= n >>> 10{32-x-1}11(0|1){x-1}
n |= n >>> 20{32-x-1}1111(0|1){x-3}
n |= n >>> 40{32-x-1}1111 1111(0|1){x-7}
n |= n >>> 80{32-x-1}1111 1111 1111 1111(0|1){x-15}
n |= n >>> 160{32-x-1}1111 1111 1111 1111 1111 1111 1111 1111(0|1){x-31}

总共右移了31位，去掉溢出的31位（所以后面不确定的数是x-31<0）：

  • 除掉不确定的位数x => 还需要溢出31-x个已知为1的位；
  • 所以剩余为1的位数为：32-（31-x） = x+1位
  • 结论：n最终为：0{32-x-1}1{x+1}；即：
    然后再将n+1，得到0{32-x-2}10{x+1}

举个例子，传入21，减一后为20（0000 0000 0000 0000 0000 0000 0001 0100）

操作操作后n的值溢出位数
初始值0000 0000 0000 0000 0000 0000 0001 01000
n |= n >>> 10000 0000 0000 0000 0000 0000 0001 1111 -1
n |= n >>> 20000 0000 0000 0000 0000 0000 0001 1111 —3
n |= n >>> 40000 0000 0000 0000 0000 0000 0001 1111 ---- —7
n |= n >>> 80000 0000 0000 0000 0000 0000 0001 1111 ---- ---- ---- —15
n |= n >>> 160000 0000 0000 0000 0000 0000 0001 1111 ---- ---- ---- ---- ---- ---- ---- —31

表中标记的都是确定为1的数，"-"代表被溢出的数；
得到11111即31,31+1=32；返回32.

这里通过计算得到了>=初始化容量 的最小2的整数次幂；之后在put时调用resize()方法初始化容量。

非理性地界生物
关注
HashMap的容量为什么必须是2的幂？
12-21
标题所提到的问题——HashMap的容量必须是2的幂，这是一个关键的设计决策，涉及到哈希表的性能和空间利用率。 HashMap的默认初始容量是16，这是2的4次方。当使用带容量参数的构造函数创建HashMap时，传入的容量会被...
HashMap的容量为什么必定为2的次幂
雨过天晴的博客
12-15 242
HashMap的容量为什么必定为2的次幂
为什么HashMap的长度是2的整数次幂？
qq_27037397的博客
12-01 177
先说答案： 为了加快哈希计算以及减少哈希冲突 为什么可以加快计算？ 我们都知道为了找到 KEY 的位置在哈希表的哪个槽里面，需要计算 hash(KEY) % 数组长度 但是！% 计算比 & 慢很多 所以用 & 代替 %，为了保证 & 的计算结果等于 % 的结果需要把 length 减 1 也就是 hash(KEY) & (length - 1) 这个 hash(KEY) 没什么可说的，调用 Object 里面的 native 方法完成计算，一般返回的是一个整数，至于是偶数还是
HashMap容量为什么是2的n次方？如何做到的？
进击的Coder*的博客
04-12 6704
HashMap无疑是我们最常用的集合之一了，当我们调用HashMap(9)构建map的时候，它的容量是多少呢？ 划重点！HashMap(9)构建的map的容量是16！！！这也就引出了下面的问题： HashMap的容量为什么是2的n次方？HashMap是如何保证容量是2的n次方的？ HashMap容量取2的n次方，主要与hash寻址有关。在put(key,value)时，putVal()方法中通过i = (n - 1) & hash来计算key的散列地址。其实，i = (n - 1) &
为什么hashmap的容量必须是2的n次幂
styhm的专栏
11-18 3177
要明白为什么是2的n次幂，这要从hashmap的hashCode方式说起，hashmap的容量期望就是用来均匀散列存放map中的元素。hashmap根据hash值把元素放到hashmap内部数组的一个位置上。 1、为什么hashmap的容量必须是2的n次幂？？ 我们不妨先看看hashCode的原理，以String为列，获取hashCode的方法源码 public int hashCode() { int h = hash; if (h == 0 &amp...
HashMap的底层数组的容量为何一定要为2的整数次幂
玄月沐影的博客
04-06 478
我们先看下在初始化赋值HashMap长度的时候调用的方法 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;
深入理解Java之HashMap —— 03
12-21
通过一系列位运算，将cap的所有低bit设置为1，然后与自身进行按位或操作，这样可以将小于最高bit的其他bit也设为1，最终使结果变为下一个2的幂。如果cap已经是2的幂，这个操作会使cap加1，以避免返回原值。 3. **...
java中hashmap容量的初始化实现
08-25
但是，如果我们通过构造函数指定了一个数字作为容量，那么HashMap会选择大于该数字的第一个2的幂作为容量。 为什么要设置HashMap的初始化容量？在《阿里巴巴Java开发手册》中，有一条开发建议是建议我们设置HashMap...
【并发】为什么HashMap是线程不安全的？
12-21
3.为什么hashmap不安全 why 3.1 插入HashMap.put 3.1.1 HashMap 在扩容的时候 3.2 HashMap 在删除数据的时候 0.背景 经常会看到说HashMap是线程不安全的，ConcurrentHashMap是线程安全的等等说法，不禁有个疑问，...
Java——HashMap
12-21
Java——HashMap HashMap 底层: 哈希表存储(数组+链表+红黑树) 特点: 查询,增删效率高,但是无序,存储键值对的值 去重: 根据key做去重,根据key计算桶的位置 扩容: 初始容量: 默认初始用量为16 加载因子: 0.75 当16*...
HashMap的容量为什么是2的N次幂？
qq_46343559的博客
06-25 726
这个问题是很多学习hashmap都会有想过的，为啥啊？当初我也是这么想的。。 一、了解hashmap的索引计算 这里就不画红黑树了，反正我也不会。 知识点： 当链表长度达到8并且数组长度大于等于64就转为红黑树，当链表长度小于6就转为链表。 当链表长度达到8但数组长度小于等于64就选择扩容，将数组长度乘以2 扩容阈值=数组长度*负载因子 当整个数组的所有容量大于扩容阈值时就进行扩容 索引就是往hashmap存值时，计算key的索引，然后选择往哪个数组存值 计算索引位置的公式为：(n - 1).
对于HashMap的长度必须是2^n的总结
m0_57713282的博客
04-09 922
一：为什么HashMap的长度必须是2^n？ 首先，如果想要元素散列在一个长度之内，可以直接使用模运算，使用取余数的方法。但是如果想要提高计算机的运算效率，可以使用位运算。通过对 “长度”-1 进行与运算，一样可以达到散列的效果，从而把元素散列在固定长度之内。但是该“长度”必须要满足一个条件，而该条件就是我们的2^n。 二：为什么符合2^n就可以达到散列效果？ 首先，我们需要了解2^n的二进制结构：最高位是1，其余为都是0，如2^3 = 1000; 那么(2^n) - 1 实际就是1000-0001
hashmap扩容为何为何是2的n次幂
lx9876lx的博客
06-06 900
hashmap 的内存结构是数组加链表 为了使值均匀的分布在数组里，尽可能减少碰撞，增加查询的效率，减少空间的浪费。 可以使用key的hashcode去查找，因为hash的时间复杂度是1，速度比较快。 然后hash值取模 % 数组的长度 -1。 但是与运算& 比取模%速率要快些。 所以Java官方使用了与运算&。 运算&的特点是11为1，10 或者00为0。 这里有个比较巧妙的地方就是： 2的n次幂转换为2进制最后一位都是0 8 1000 16 10000 因为key的hash值是跟
hashmap扩容为什么是2的幂
一个搬砖工人
04-07 1779
HashMap的初始容量都是2的n次幂的形式存在的，而扩容也是2倍的原来的容量进行扩容，也就是扩容后的容量也是2的n次幂的形式存在的，下面就来说明一下为什么是2的n次幂的形式！ 先来看一下源码，也就是向HashMap中添加元素，或者扩容时是怎么存放元素的。 第一个截图是向HashMap中添加元素putVal()方法的部分源码，可以看出，向集合中添加元素时，会使用(n - 1) & hash ; n = table.length的计算方法来得出该元素在集合中的位置；而第二个截图是HashMap扩容
HashMap容量为什么是2的幂次（清晰）
大帅哥的博客
11-26 3287
HashMap容量为什么是2的幂次（清晰）why？最终 为了快速运算出键值对存储的索引和让键值对均匀分布 1、首先计算键值对的索引要满足两个要求：不能越界、均匀分布 而 h % length （h根据key计算出来的哈希值）就能满足这一点，但是取模运算速度较慢。 容量为2的次幂时、而 h & (length-1)刚好也能满足，而且按位与运算速度很快。 why？ 32位的哈希值下面为了方便只写几到十几位 如：当length=16时，length-1=15 16: 0001 0000 -- le
HashMap浅析一：为什么HashMap的容量是2的指数幂
loet6010的博客
06-12 1357
集合是 Java 开发中使用频率非常高的，而其中HashMap更是经常使用的一种集合类型。其实现Map接口，是一种K-V结构的数据集合，底层是由数组加链表形式组成的。这一系列主要从源码上去了解并学习分析HashMap，JDK版本为1.8。 本次主要分析一个问题，为什么HashMap的容量是2的n次幂？ 首先需要了解的是HashMap的机构，其K-V结构是个数组加链表形式，key通过hash运算确定数组的位置，key-value则存储在数组对应的链表中。如下图所示： 由此可见，hash运算确定数组位置就非常
说一说HashMap的长度为什么是2的幂次方
小缘同学的博客
12-10 8284
答： HashMap长度为2的幂次方的原因是为了减少Hash碰撞，尽量使Hash算法的结果均匀。 首先看一下HashMap中putVal方法的源码 其中有个( n - 1) & hash的方法，那么这个方法是干什么的呢？ HashMap为了存取高效，就要尽量减少碰撞，将数据分配均匀，那么如何分配均匀，此时主要靠将数据存入到那个链表中的算法，这个算法就是( n - 1) & hash。& 是按位与运算，是一个位运算，而在计算机中位运算的效率很高，这就...
HashMap的长度为什么是2的N次幂，如何实现的？
任意门的博客
10-28 588
问题： 看过HashMap源码的人可能都用印象，就是hashMap的哈希表长度可以由自己指定也可以不指定使用默认长度，但是如果在了解或者发现tableSizeFor方法的话，你就会知道此方法会改变我们的输入长度 (如果我们输入15，他会改为16)，那么他为什么要修改我们设置的长度，以及修改后有什么作用？带着这个疑问我们往下看； HashMap的长度为什么是2的N次幂? 为了能让hashMap存取高效，尽量减少碰撞，也就是要尽量把数据分配均匀。 Hash值的取值范围-2147483648到2147483
hashmap容量为什么是2的幂次
最新发布
08-08
HashMap的容量为什么要设定为2的幂次呢？这主要是出于效率的考虑。 首先，HashMap的主要功能是通过散列（hashing）将键（key）映射到对应的值（value）。而散列算法通常是以键的哈希码（hash code）为基础进行计算...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

非理性地界生物

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值