HashMap原理分析：初始化HashMap

一. HashMap的初始化

从构造方法可以看出来，涉及到四类方法 ，总结的话，大致分为两类：

第一类是HashMap();初始化了负载因子全局常量

    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

第二类是HashMap(Map<? extends K, ? extends V> m)，这个方法是将另外一个map里面的值赋值给当前map。

    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        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判断当前map是否为空，为空的话初始化容量
                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)//当m的大小超出阈值时，扩容
                resize();
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {//赋值给当前map
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

第三类是以HashMap(initialCapacity,loadFactor)为核心的HashMap(initialCapacity)、HashMap(initialCapacity,loadFactor)两个方法，这个主要是初始化负载因子以及阈值

//初始化
HashMap<String, String> h = new 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);//初始化阈值
}

初始化时，HashMap里面的两个参数，loadFactor为负载因子（即扩容的机制，默认为0.75） ；

initialCapacity为初始化容量,这里我打debugger的值为11，具体在哪儿赋值成11的，还没找到，有大佬知道的话期待指点迷津。方法里的tableSizeFor(initialCapacity)之后是16，将公共变量threshold即当前map大小初始化为16，HashMap在初始化时会将阈值设置为16，就是通过tableSize这个方法实现的。tableSize(initalCapacity)的方法如下：

/**
 * Returns a power of two size for the given target capacity.
 */
static final int tableSizeFor(int cap) {
	int n = cap - 1; //cap=11;n=10
	n |= n >>> 1;    //n换算为2进制为：1010；向右移一位变为：0101；n|=n>>>1=》n=n|n>>>1;
                     //也就是 n= 1010 | 0101 = 1111,换算为10进制是15；
	n |= n >>> 2;    //n换算为2进制为：1111；向右移动两位变为：0011；结果是n=1111|0011 = 1111;
	n |= n >>> 4;    //。。。以此类推
	n |= n >>> 8;
	n |= n >>> 16;   
	return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    //n为15，三目运算表达式结果为n+1=16;所以map在初始化的大小为16；
}
这个的作用，就是将所有位数转化为1，然后最终转化为2的n次方

这里涉及到无符号右移，看到一个很不错的博文，解释的很清楚：java中右移运算符>>和无符号右移运算符>>>的区别

我的其他文章（持续更新）

• HashMap原理分析：put()
• HashMap原理分析：get()