Java-HashMap源码之构造函数

1，HashMap()型构造函数

2，HashMap(int)型构造函数

3，HashMap(int, float)型构造函数

4，HashMap(Map<? extends K, ? extends V>)型构造函数

今天暂时阅览前三种构造函数

package java.util;

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
			
	//默认负荷因素大小-达到当前容量的0.75时，将会扩容
	static final float DEFAULT_LOAD_FACTOR = 0.75f;	
	
	//Hash table的加载因子。
	final float loadFactor;
	
	//最大容量,如果具有参数的任一构造函数隐式指定更高的值,则使用该最大容量.必须是2的幂<= 1 << 30。
	static final int MAXIMUM_CAPACITY = 1 << 30; //2的30次方，1,073,741,824
	
	//调整大小的下一个大小值（容量*加载因子）。
	int threshold;
	
	//使用默认初始容量(initialCapacity:16)和默认加载因子(loadFactor0.75)构造一个空的HashMap。
	public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
    }
	
	//@throws IllegalArgumentException 如果initialCapacity为负数。
	public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
	
	//@throws IllegalArgumentException 如果initialCapacity为负数或loadFactor为负数。
	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);
    }
	
	//返回比cap大的最近的2的n次方
	static final int tableSizeFor(int cap) {
		//if cap=10：00001010
        int n = cap - 1;//n=9:0-0(24个0)+00001001
		//n|=n>>>1 : n=n|(n>>>1)
		//暂时前24个0省略
        n |= n >>> 1;	//n = 00001001(9) | 00000100(4) = 00001101(13)
        n |= n >>> 2;	//n = 00001101(13) | 00000011(3) = 00001111(15)
        n |= n >>> 4;	//n = 00001111(15) | 00000000(0) = 00001111(15)
        n |= n >>> 8;	//n = 00001111(15) | 00000000(0) = 00001111(15)
        n |= n >>> 16; 	//n = 00001111(15) | 00000000(0) = 00001111(15)
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;// n = 16
    }
}

 

 以上可以看出：

HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。

HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。

HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。

以下是各个变量解释：

initialCapacity：初始容量

loadFactor：负载因子，例如loadFactor=0.75，则当数据当达到容量的0,75时，将会扩容

MAXIMUM_CAPACITY：最大容量，2的30次方，当扩容后容量大于最大容量时，容量为最大容量

threshold：capacity * loadFactor；