HashMap底层原理分析（一）

一：内部参数定义

默认初始化数组容量16 （数组容量必须为2的幂次方）

/*
	解释：先将1转为二进制表示形式：     0000 0001
		             左移四位：		 0001 0000    --> 16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

最大容量：

// 01000000 00000000 00000000 00000000     int最大长度，第一位是符号位
static final int MAXIMUM_CAPACITY = 1 << 30;

默认负载因子0.75
树化阈值8
反树化阈值6
最小树化数组容量64

int threshold  //所能容纳的key-value对极限，超过此值，自动扩容
int size   //实际HashMap中存在的键值对数量

二：功能方法实现

1.确定哈希桶数组索引位置
前言：当我们使用HashMap进行增删改查的时候，首先要确定哈希桶数组索引位置i，因此这是至关重要的一步：
jdk源码：

//JDK1.8版本
  第一步： Object类型的key值调用hashCode（）方法得到key的hashCode值、高位运算得到h
    static final int hash(Object key) {
        int h;
        // h = key.hashCode() 为第一步 取hashCode值
        // h ^ (h >>> 16)  为第二步 高位参与运算（异或）
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    
  第二步：将h与数组长度-1进行位与运算得到哈希桶数组索引位置i
    static int indexFor(int h, int length) {  
     return h & (length-1);  

问题1：为什么要key.hashCode()后要进行高位与运算？
答：主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。
问题2：为什么不用取余运算，而采用h & (length-1)？
答：hash%length 等价于 hash&(length-1) 【!!前提条件是length是2的n次幂!!】；
而HashMap中数组长度必须位2的n次幂，这样就保证了上述等价关系的成立；
采用二级制位操作&，能提高运算效率。

2.HashMap的put()方法

HashMap的put方法执行过程可以通过下图来理解：
（图中判断链表长度是否大于8应该在链表插入之后，这一点与源码有出入。）

源码分析：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //1.判断数组是否为空，如果是空，初始化数组，并记录数组长度n
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //判断当前索引i位置是否为空，如果是空，就将newNode添加到该位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //判断当前要添加元素是否等于当前索引i位置上的元素，如果是，就将其覆盖。
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //判断当前索引i位置的元素是否是树，如果是树，就当前元素直接将其添加。
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
            	//当前索引位置元素是链表，必须遍历。
                for (int binCount = 0; ; ++binCount) {
                	//找到链表的最后一个元素将当前元素添加到最后。
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //添加之后，判断是否满足满足长度大于树化阈值，满足就树化
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //在遍历过程中，发现存在元素和当前元素相等，退出遍历。
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //退出遍历之后，使用当前元素覆盖原有重复的元素。
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //如果数组占用容量大于临界值，自动扩容。
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

３.扩容机制
引言：扩容就是重新计算容量，当前加入数组中的Node数量大于设置的阈值时，就会自动扩容，默认扩容大小为之前数组长度的两倍。
JDK1.7源码：

 1 void resize(int newCapacity) {   //传入新的容量
 2     Entry[] oldTable = table;    //引用扩容前的Entry数组
 3     int oldCapacity = oldTable.length;         
 4     if (oldCapacity == MAXIMUM_CAPACITY) {  //扩容前的数组大小如果已经达到最大(2^30)了
 5         threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
 6         return;
 7     }
 8  
 9     Entry[] newTable = new Entry[newCapacity];  //初始化一个新的Entry数组
10     transfer(newTable);                         //将数据转移到新的Entry数组里
11     table = newTable;                           //HashMap的table属性引用新的Entry数组
12     threshold = (int)(newCapacity * loadFactor);//修改阈值
13 }

关于新旧数组中元素移动的解析：transfer()方法

 1 void transfer(Entry[] newTable) {
 2     Entry[] src = table;                   //src引用了旧的Entry数组
 3     int newCapacity = newTable.length;
 4     for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
 5         Entry<K,V> e = src[j];             //取得旧Entry数组的每个元素
 6         if (e != null) {
 7             src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
 8             do {
 9                 Entry<K,V> next = e.next;
10                 int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
11                 e.next = newTable[i]; //标记[1]
12                 newTable[i] = e;      //将元素放在数组上
13                 e = next;             //访问下一个Entry链上的元素
14             } while (e != null);
15         }
16     }

解释：
e.next = newTable[i]：当前（加入）Node指向数组的节点，组成一个新链表；newTable[i] = e：新链表头节点放到数组中。先添加节点，后将头节点动至数组。也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链表的头部位置。

JDK1.8中的优化：（!!!）
不需要重新计算hash去决定当前元素再新数组中的索引位置，只需要看原来的hash值新激活的bit位是1 or 0，是0的话当前元素再新数组中索引位置不变，是1的话索引变为：“原索引位置i+原数组容量”。

参考

[1] JDK1.7&JDK1.8 源码
[2] https://zhuanlan.zhihu.com/p/21673805