1.简介（其实是HashMap注释的大致翻译）
本文基于JDK1.8，与JDK1.7中的HashMap有一些区别，看官注意区别。
HashMap实现了Map接口，提供了高效的Key-Value访问。HashMap与HashTable非常类似，除了HashMap允许key和value为null，并且HashMap非线程安全，而HashTabel则是线程安全的。HashMap不保证插入键值对的顺序；也不保证在不断的插入和删除后，键值对的顺序会保持不变（保证顺序的有LinkedHashMap）。
如果HashMap中的元素均匀的分布在桶中，那么put和get操作能接近与常量级的时间消耗。在HashMap上进行迭代需要的时间收到容量的影响，所以不要在初始化时，把初始化容量设置的过大，或者负载因子设置的过小。
通常情况下，默认的负载因子，0.75能很好的权衡时间消耗和空间消耗。将负载因子设置大一些能提高空间利用率，但是也会提高查询时间的消耗。
如果会有很多的元素会存在HashMap当中，在创建时设置一个相对较大的值，来避免自动的扩容和rehashing，这样能提高效率。如果很多key具有相同的hashCode()值，会降低HashMap的性能。
注意HashMap不是线程安全的，如果想使用线程安全的Map，可以使用 Collections.synchronizedMap 、HashTable、ConcurrnetHashMap替代他。
HashMap返回的 iterator（迭代器）是快速失败的（fail-fast）。如果在迭代过程中，有其他线程修改了hashMap（put，remove），会抛出一个ConcurrentModificationException，但是使用迭代器本身的 remove方法不会。
2.HashMap内部数据结构和成员变量
HashMap成员变量有以下这些（不包括类变量）：
transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
transient int size;
transient int modCount;
int threshold;
final float loadFactor;
table变量就是实际上存储元素的地方，是一个内部数据结构Node的数组。
entrySet实际上内部不保存元素，并且直到调用entrySet()之后才会真正的实例化，否则一直都是null。因为HashMap没有实现迭代器接口，table变量也不是单纯的数组，实际上会演变成数组+局部链表或数组+局部红黑树的结构。平常对HashMap的遍历，通常会调用entrySet()方法，获取entrySet变量，然后进行遍历。
size变量保存的是当前已经插入的元素数量，而不是table的长度。
modeCount被用来实现快速失败机制。在通过entrySet遍历时（entrySet().iterator()，无论是直接使用迭代器，还是使用 foreach循环，都是相当与调用了该方法），每次都会创建一个新的迭代器变量，其中保存了当时状态下的modCount，在调用HashMap的put、remove等方法时，modeCount都会递增，遍历下一个元素时（next()），会检查此时的modeCount是否和创建迭代时保存的modeCount是否一致，否则抛出异常。
threhold是容量 * 负载因子，当 size超过该值时会触发扩容和rehashing的操作。
loadFactor就是负载因子，决定了当HashMap达到“多满”是会进行扩容操作。
HashMap的内部数据结构有：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
}
这里只列举了两个，其他还有一些 entrySet的类，values方法返回值的类，keys方法返回的类，以及他们对应的迭代器，这里就不介绍了。
Node类，就是上述table中保存的实例的类，其中有 hash --不等同与hashCode()的值，但是与hashCode()值关系紧密，相同的hashCode()则对应相同的hash值；key就是键，通过key来查询保存的value；value就是保存进来的值；next指向了下一个节点，为元素冲突时提供了解决方案。可以看到，实际上HashMap中不仅仅会保存value，同样会保存一些必要的信息（废话！）。
TreeNode是Node的一个子类（LinkedHashMap.Entry继承自Node）。当HashMap中某一个桶位冲突太多，这个位置上的链表就会变得很长，降低了查询的效率，这时候需要将链表转化为一颗树，Node节点会转化为TreeNode作为子结点，提升查询的效率（为什么不一开始就是用树结构，维护树结构不要时间哒！），冲突的数量减少到一定量（remove），树会退化为链表，TreeNode也会转化Node。
3.HashMap逻辑存储结构
图一（鼠标移动到图上面就能看到对应的标题了）展示了无冲突情况下的table结构。
图二展示了某一个桶位置有一定量冲突情况下的table结构。
图三展示了某一个桶位置大量冲突，从链表转换为树结构。
（所谓的桶位就是table这个数组的某一个位置，三张图中蓝色表示已经一个不为null的Node）
4.HashMap实现原理
先从几个关键内部方法入口，再来探讨HashMap对外暴露的关键方法。
4.1 计算Table Size
计算 HashMap中table应该初始化或者扩容时的长度。HashMap中的table长度都是2的幂次方，为什么这么做，是为了能保证元素能够在table上面均匀分布，为什么能保证，课后作业~
代码的执行结果是获得一个 大于等于 cap的最小2的幂次方数。这个算法非常巧妙，分析如下：
首先cap的取值范围为，>=0；那么 n >=-1；
当 n = 0 时，在 return语句之前，n的值为0，最后返回结果为 1；
当 n = -1，应为最高位 一直是 1（不理解的复习一下 补码了），因此是个负数，最后返回结果为1；
当 n > 0时，任何一个 整数二进制可以表示为 001XXXXX （做个解释，这里的1是表示最高位的1，前导全部是0，而这里前导0数量并不表示一定是2个，简化一些，下面运算方便一点，后面的X表示，可能为1，也可能为0，实际上我们并不关心，但是整个二进制串的长度是32）
第一次运算： n | = n >>> 1，即：
001XXXXX |
0001XXXX =
0011XXXXX ； 现在我们能保证前导0之后至少有2个连续的1（或者说已经到此时保证除了前导0之外，全部都是1，下不赘述）；
第二次运算： n |= n>>>2，即：
0011XXXXX |
000011XXX =
001111XXXX ；现在我们能保证前导0之后至少有4个连续的1。
依次类推，最后我们能得到一个数字，他除了前导0之外，全部都是1。
n+1 就是得到了 一个 2的幂次方，并且是大于等于 cap的最小 2的幂次方数。
为什么这里 要先将 cap -1呢？因为是为了防止 cap已经是 2的幂次方数，可以尝试一下上面的算法，如果不将cap -1，那么得到的树就会变为 cap的两倍，但是显然没必要，我们希望的是cap。
/**
* Returns a power of two size for the given target capacity.
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
4.2 Hash算法
相较于1.7的Hash算法，1.8简单了不少。不直接使用hashCode()来作为hash值，是为了避免更少的冲突，（可以参考其他的博文），相对于1.7的计算方法，明显简化了很多。官方说法是，这样做是 综合考虑了 实用性，效率。（也就是这么做已经能保证大多数情况下较低的碰撞率，计算方法也相对简单高效，对了，碰撞的意思就是不同的key分配到相同的一个桶位，这样就不得不演变成链表或者树的形式）。
具体的算法就是，key == null 则返回0；否则 等于 key.hashCode() 亦或 key.hashCode()无符号右移16位。
static final int hash(Object key) {
int h;
//这里也间接证明了 key 可以为 null
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
4.3 计算桶位（该放到table数组的哪个位置）
1.8中没有将他独立成一个方法，从putVal()方法中截取一段。 n 就是 table的长度，hash就是 key通过上述的 hash算法计算出来的值。有的人可能会认为table的长度为 2的幂次方 是为了 能快速计算下标（使用 &运算符），并且计算出来的下标不会超过table长度。实际上不是的，事实上，table的长度为2的幂次方是为了最大化的降低冲突的概率，并且对于任何一个整数 n，都能使用 (n-1) & length 来计算下标，并且计算出来的结果小于n。
(n - 1) & hash
4.4 put方法(插入一个元素)
1.8 中，是直接调用
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict)
第一个参数是 我们前秒写的 hash方法计算出来的值；最后两个 boolean参数 这时候都是 false。
直接参照源码和注释理解这个方法。
4.5 resize 扩容
扩容操作，不仅仅需要扩大table的长度，Node所在的位置也会发生变化(实际上，如果原table的长度为n，Node所在下标为t，那么在新table中，一个Node所在的下标要么是 t，要么是t+n，没有其他选择)。为什么？
1. 原来的表 table 长度为 001000000；
2.那么新table 长度为 010000000 ;
3.在旧table 中下标 t = 000111111 & hash = 000XXXXX (x可能为1 也可能为 0)
4。在新table 中下标 T = 0011111 & hash = 00MXXXXX，和t相比，除了 M可能是1 可能 0 之外，每一个T中的X 和 t中的 X 都是一样的（想想为什么，应为都是 hash & 11111嘛，肯定是一样的嘛！）
5. 如果 M = 0，那么 T = 000XXXXX = t ； 如果 M =1 ，那么 T = 001XXXX = t + 0010000 = t + oldCap = t + 原 table的长度
6. 那么什么情况下 M 会是 0 呢？ 什么情况下M 或是1呢？显然，当 hash = XX0XXXX的时候，M = 0，也就是说 hash & (newCap -1 ) = XX0XXXX & 00111111 = 000XXXXX = hash & (oldCap -1 )；
可一继续推导一下，当 hash & oldCap = 0 的时候，那么 M = 0。（证明不是很严谨哈）
同样直接按照源码和注释理解这个方法。
final HashMap.Node<K,V>[] resize() {
//前面这一段没什么好说的，扩容 table长度的两倍，threshold通常情况下是 CAPACITY * LOAD_FACTOR;如果 table长度已经是
//最大了，那么 threshold也会变成 Integer.MAX_VALUE.
HashMap.Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//这里因为只有变化了 threshode,容量没有变化，所以Node位置不需要发生变化，直接返回了。
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
//重新创建一个 新长度的数组
HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
table = newTab;
if (oldTab != null) {
//遍历老的 table
for (int j = 0; j < oldCap; ++j) {
HashMap.Node<K,V> e;
if ((e = oldTab[j]) != null) {
//老的 table已经不用了，因此直接赋值为null，可以回收掉
oldTab[j] = null;
//如果 e的下一个节点是 null，就是说 这里没有链表 或 树的结构，那么重新计算下表，赋值到新的table
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//树节点的变化，有空在分析
else if (e instanceof HashMap.TreeNode)
((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//到这里就是对链表的重新分配了，注意，原Table中某些key会被计算到同一个下标，但在新的下表中却不一定
// 因此链表可能会拆散，变成0-2个链表，为什么，可以前面描述哈。
//所以这里定义两个node对,一个是 loHead,loTail;一个是 hiHead,hiTail
HashMap.Node<K,V> loHead = null, loTail = null;
HashMap.Node<K,V> hiHead = null, hiTail = null;
HashMap.Node<K,V> next;
do {
//循环遍历
next = e.next;
//e.hash & oldCap == 0 的Node 会被分配到同一个位置，确切来说，和原table的下标是一样的
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//其余的节点会被分配到 另外一个 同一位置，确切来说是 原table下标 + oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//这里就没什么了，在对应的位置上赋值就可以
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
5. 常见面试题
Q: table数组什么时候获得初始化?
A: 第一次插入元素的时候
Q:new HashMap().put()，就是初始化hashMap之后，第一次放入元素，table的长度是多少
A:16
Q:new HashMap(19)，创建的map中table数组长度会是多大。
初始化时实际上是 null，第一次插入元素时是32.