Java-HashMap源码之构造函数

柔情只为你懂 2021-09-29 09:46 332阅读 0赞

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；