前言
会涉及以下问题
HashMap的put方法、get方法的认识
HashMap的扩容机制、默认大小是多少？
什么是负载因子（填充比）？
什么是吞吐临界值（阈值、threshold）
key可以为null吗？
HashMap存储结构（JDK1.7及1.8）
内存结构说明
HashMap在jdk7中实现原理
HashMap map = new HashMap():
*1、在实例化以后，底层创建了长度是16的一维数组Entry[] table。装载因子是0.75（为了让链表不臃肿），阈值是12.
*2、...该操作表示可能已经执行过多次put...
*3、map.put(key1,value1):
* 3.1、首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后（&15），得到在Entry数组中的存放位置。
* （1）如果此位置上的数据为空，此时的key1-value1添加成功。 ----情况1
（2）如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：
* 1）如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
* 2）如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，相同更新，不同插入（头插法）情况3
* 补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
*
* 在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原的数据复制过来。
实现原理对应的源码
HashMap map = new HashMap():
* 1、在实例化以后，底层创建了长度是16的一维数组Entry[] table。装载因子是0.75（为了让链表不臃肿）.
* 1.1/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
(16) and the default load factor (0.75).
*/
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
1.2 阈值是12=(int)Math.min(16*0.75,1 << 30+1)
threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
1.3 创建了长度是16的一维数组Entry[]
table = new Entry[capacity];//capacity=16
* 2、...该操作表示可能已经执行过多次put...
* 3、map.put(key1,value1):
* 3.1 key是否是null，特殊的处理
* if (key == null) return putForNullKey(value);
* 3.2 首先，调用key1所在类的hashCode()计算key1哈希值此哈希值经过某种算法计算以后（&15），得到在Entry数组中的存放位置。
* int hash = hash(key);//hashcode()加上一些异或操作（非常复杂）
int i = indexFor(hash, table.length);（hash&15=hash%15）
3.3 遍历判断
* 3.3.1如果此位置上的数据为空，此时的key1-value1添加成功。 ----情况1
* addEntry(hash, key, value, i);
* 1）如果插入位置大于12并且插入位置有值，扩容为2倍并且将原来数组中的元素复制一份
* //因为扩容比较耗时，所以尽管超过了12，没有产生链表的话就不扩了
* if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
3.3.2如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
* 1）如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
* e.hash!=hash
* 2）如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，相同更新，不同插入（头插法）情况3
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
验证头插法
Entry<K,V> e = table[bucketIndex]; 取出原来的entry
table[bucketIndex] = new Entry<>(hash, key, value, e);
* 注意：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
* 在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原的数据复制过来。
完整源码说明
public V put(K key, V value) {
if (key == null) //key是null也进行存储
return putForNullKey(value);
int hash = hash(key);//求出key的hash值
int i = indexFor(hash, table.length);//hash值&16得到数组坐标
//遍历该下标的整个链表
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//如果与当前下标的链表中的key的hash值一样，并且是一个key，更新操作。
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);//插入
return null;
}
//扩容
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
在jdk8中相较于jdk7的不同：
1. jdk7底层结构：数组+链表。jdk8中底层结构：数组+链表+红黑树，jdk 8底层的数组是：Node[],而非Entry[]。
2. new HashMap():底层没创建一个长度为16的数组。首次调用put()方法时，底层创建长度为16的数组
3 形成链表时，七上八下（jdk7:头插法。jdk8：尾插法）
4 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所有数据改为使用红黑树存储，>8但是数组长度<64（MIN_TREEIFY_CAPACITY），仅数组扩容就可以了，因为扩容可以让链表中的元素重新hash，可能链表就不会这么长了，扩容会让之前数组和链表中的数据重新计算。
5、hash算法简化了
HashMap底层典型属性的属性的说明：
DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64
LinkedHashMap
- LinkedHashMap底层使用的结构与HashMap相同，因为LinkedHashMap继承于HashMap.
- 区别就在于：LinkedHashMap内部提供了Entry，替换HashMap中的Node。
重写了newNode方法：增加了before，after相当于HashMap中的next，LinkedHashMap中的next废掉了。
因为有了before和after，所以底层链表是双向链表，所以此时的LinkedHashMap插入时有序，做到了增删改查平均O（1），并且有序，所以LRU和LFU都会用到这个数据结构。
