HashMap源码之构造函数--JDK1.8

构造函数

变量解释

1. capacity，表示的是hashmap中桶的数量，初始化容量initCapacity为16，第一次扩容会扩到64，之后每次扩容都是之前容量的2倍，所以容量每次都是2的次幂
2. loadFactor，负载因子，衡量hashmap一个满的程度，初始默认为0.75
3. threshold，hashmap扩容的一个标准，每当size大于这个标准时就会进行扩容操作,threeshold等于capacity*loadfacfactor

HashMap(int initialCapacity, float loadFactor)

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegalinitial 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);
}
//构造函数前面都很容易理解，无非是设置正确的initialCapacity和loadFactor
//最后一行调用的tableSizeFor(initialCapacity);如下
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(...)方法的作用在于找到大于等于initialCapacity的最小的2的幂。n右移一位再同自身进行或操作使得n的最高位和最高位的下一位都为1.

n |= n >>> 1;
比如n=9，则n=1001(2)，n-1=100
1001
0100
-----
1100
这是因为或操作的要求为相同位上只要存在1则结果为1，全为0结果才为0.一个数最高位为1，右移一位后的数最高位也为1，不论相对应的位上另一个数是多少结果依旧为1.

而对于n |= n >>> 2n的最高位及其下一位都为1，右移两位后再进行或操作将使得得到的n的前4位都为1，类似的n |= n >>> 4使得前8位为1，n |= n >>> 8使得前16位为1。当然并不是说该方法调用下来就会使得返回的值是一个32位都为1的数字，这是因为当右移的位数操作实际的有效位数后是不会对数字产生任何变化的。

以n=9为例,在进过两次右移后n=1111(2)
00000000000000000000000000001111 n (int 32位)
00000000000000000000000000000000 n>>>4
--------------------------------
00000000000000000000000000001111
当n右移4位后全部变成了0，使得结果不会发生任何变化，后面的n |= n >>> 8等等也一样

在最后返回的时候做了一个判断(n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1，正常来说返回的是一个n+1，在前面的操作中已经将前几位有效的数字变成了1(n=1111)，这里加1使得n=10000(2)，即变为大于等于initialCapacity的最小的2的幂，到这里貌似就差不多了，但是在tableSizeFor(...)方法的第一句有一个减法操作int n = cap - 1;这是为什么呢？这里减1实际上是为处理传入的数本身就是2的幂的情况。比如我传入的是n=8=1000(2)，如果不进行减1操作，得到的则是n=10000(2)=16，实际上我需要的就是8.

HashMap(Map<? extends K, ? extends V> m)

public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

这个构造函数主要是用一个已有的map来构造一个新的HashMap，这里主要在于putMapEntries(m, false);中。

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            if (table == null) { // pre-size
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            else if (s > threshold)
                resize();
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

前面几行是做容错判断，当table没有初始化或者传入的map容量大于当前map的阈值(threshold)，都需要重新进行设置。从for循环开始则是将传入的map的值插入到当前map中。