HashMap的tableSizeFor解析

我们都知道，对于HashMap来说，数组的容量为2的倍数，但是我们可以在创建map的时候传入一个数组的大小

此时，这个初始化数组大小会传给一个双参的构造器

1. 创建HashMap

    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>(10);
    }

2. 构造器

    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;
        //阈值（HashMap中最多能容纳的元素个数）
        // 阈值 = 数组长度 * 负载因子
        // 但是注意，刚初始化的时候阈值用来临时保存用户指定的初始容量或者默认初始容量16
        // 只有在第一次inflateTable()扩容之后，才会用计算出的正确的容量乘以负载因子赋值
        //此时传入的initialCapacity是10，会调用tableSizeFor方法，将其转为大于等于它的一个2的幂次数，例如7转为8,8转为8，10就转为16
        this.threshold = tableSizeFor(initialCapacity);
    }

3. tableSizeFor具体实现

    static final int tableSizeFor(int cap) {
        //首先减一操作是为了如果本身就为2的幂次数（8,16）的话，就使其降为一个小于2的幂次的数
        //例如我们传入的10，对应的2进制为00000000 00000000 00000000 00001010
        int n = cap - 1;
        //减后
        //00000000 00000000 00000000 00001001
        n |= n >>> 1;
        //右移后
        //00000000 00000000 00000000 00000100
        //之后再与自身相或也就是上面两个二进制相或
        //00000000 00000000 00000000 00001101
        n |= n >>> 2;
        //再次右移两位
        //00000000 00000000 00000000 00000011
        //再或
        //00000000 00000000 00000000 00001111
        //此时我们可以看到我们想要的效果了
        //将低位全部置为1！
        //后面这些也是一样的操作，因为int是32位的
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        //之后对 与完的数字进行+1操作，（这些判断我就不说了）
        //00000000 00000000 00000000 00010000
        //此时+1后变为了一个2的幂次
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

4. 接下来我在说两个别的例子

-首先是32，他其实最后的结果要的就是32，对应的二进制是

00000000 00000000 00000000 00100000

-接下来先减一

00000000 00000000 00000000 0001 1111

-此时其实我们不用看了，右移之后或上任何数字，此时最后5位是不会变的，都是5个1

00000000 00000000 00000000 0001 1111

-之后对其进行+1操作，就变回了我们的32

00000000 00000000 00000000 0010 0000

-在接下来是很大的数字，这个数字具体是多少我也没算过。。。也不知道，最大容量MAXIMUM_CAPACITY = 1 << 30，所以应该是没超的

注意观察最高位

0010 0000 0010 0100 0101 1000 0010 0101

-先减一

0010 0000 0010 0100 0101 1000 0010 0100

-在右移1位

0001 0000 0001 0010 0010 1100 0001 0010

-此时上面两个相或

0011 0000 0011 0110 0111 1100 0011 0110

--此时再右移两位

啊！不想右移了，我们看一下结果吧

我们观察一下上面一堆，可以发现我们的结果其实与后面几位无关，只与最高的那个1位有关

-例如我们最近的这个

0010 0000 0010 0100 0101 1000 0010 0101

-我们其实可以省略除了最高的那个1之外的数字，我们将他们全部忽略，使用*代替，表示我们不关心它

001* **** **** **** **** **** **** ****

-之后右移一位

0001 ****

-相或

0011 ****

-之后右移两位

0000 11**

-相或

0011 11**

-右移四位

0000 0011 11** **

-相或

0011 1111 11** **

通过不断的这样的操作，将最高位1之后位全部置为1

之后在+1就可以求出来一个2的幂次了

5. 那有些朋友可能会问了，开始为什么要减一呢？

因为对于以下数字，我们可以看出来，减一实际上并没有什么影响，甚至你减个88都没什么影响，那为什么减呢？

0010 0000 0010 0100 0101 1000 0010 0101

主要是为了解决2的幂次的存在

因为对于2的幂次来说，例如32

00000000 00000000 00000000 00100000

我们如果直接去计算,直接右移取或，右移取或

那么我们得到的结果是

00000000 00000000 00000000 00111111

此时最终+1取2的幂的话结果为64！但是我们要的是32，所以说要先减1，使其成为一个比2的幂次小的数字

00000000 00000000 00000000 01000000