基本知识
Map
在HashMap中，有一个继承的接口Map<K,V>，Map接口实际就是映射，通过键来获取值。在Java的官方注释中是这么描述的：
An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value.
这个的大致意思就是：将键映射到值的对象。映射不能包含重复的键；每个键最多可以映射到一个值。
哈希表/散列表
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
HashMap结构
HashMap结构实际上是由数组+链表+红黑树组成的，执行如下的代码：
HashMap<String, Integer> map = new HashMap<String, Integer>(64, 1);
map.put("aa", 1);
map.put("bb", 2);
map.put("cc", 3);
map.put("dd", 4);
map.put("ee", 5);
map.put("ff", 6);
map.put("gg", 7);
map.put("hh", 8);
map.put("ii", 9);
map.put("jj", 10);
map.put("kk", 10);
map.put("ll", 10);
map.put("mm", 10);
map.put("nn", 10);
map.put("oo", 10);
map.put("pp", 10);
map.put("qq", 10);
可以的得到如下的内存结构：
红黑树：
链表：
HashMap的数据结构图：
重要参数
loadFactor
loadFactor是哈希表的负载因子，负载因子会影响到HashMap的扩容，负载因子越大，HashMap的碰撞越剧烈，但是resize越少；负载因子越小，HashMap碰撞概率越小，但是resize越多。
threshold
threshold是HashMap要扩容的阈值，在HashMap的源码中是这么描述的：
The next size value at which to resize (capacity * load factor)
这个代表着threshold是整个HashMap的容量 * 负载因子得出来的值。当容量大小等于这个阈值的时候，HashMap就会扩容。
重要方法
put方法
在HashMap中最常用的方法就是put方法了，put方法主要的作用就是将Key-Value插入到Map中，在HashMap中put方法的特点是：
- 可以重复插入；
- 插入的KEY和Value都可以为Null
HashMap put方法的大致思路是：
- 首先将Key的hashCode计算，得到对应的hash值；
- 判断HashMap里面的槽是不是空的，如果是空的就需要初始化HashMap里面槽的数量；
- 判断这个Key所对应的槽是否被占用，如果没有被占用，就将Key-Value生成一个新的节点，放到对应的槽中
- 如果这个槽被占用了，分成三步判断：
4.1. 判断Key是否相同，如果相同则返回原有的Node，如果不相同则进行下面的判断；
4.2. 判断节点是否属于树节点(TreeNode)，如果属于，则添加到红黑树中；
4.3. 如果不是树节点，则一定是链表的Node，遍历链表，如果链表长度大于等于7了，则将链表转换成为红黑树，否则则添加到链表中； - 最后判断HashMap的大小是否大于阈值，如果大于，则进行扩容
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
// 如果当前HashMap里面的存储数据的table是空的，或者table的大小是0，那么就初始化table
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// 如果table里面对应这个Key的槽为空，就直接创建一个新的Node，添加到table中
tab[i] = newNode(hash, key, value, null);
else {
// 到这里已经证明table里面的槽已经被其他的Node占用了
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 判断被占用的Node的Key和当前的Key是否为同一个，如果是同一个，则取出这个Node
e = p;
else if (p instanceof TreeNode)
// 判断这个Node节点是否是一个树节点，如果是的话，就把这个新的Key-Value添加到树中间去
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 如果都不是的话，则这个Node节点一定是一个链表节点
for (int binCount = 0; ; ++binCount) {
// 循环遍历链表
if ((e = p.next) == null) {
// 判断是否到了链表末尾，如果已经到了链表末尾，则创建一个新的Node
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 判断当前链表的长度是否大于等于构建树的阈值（7），如果大于等于，就将链表转换为红黑树
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// 如果链表中有一个Node的Key和当前的Key相同，则直接break
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
// 如果不是创建模式或者原来的值为空，则直接把当前的值存放到这个Node的值上面
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
// 如果当前表的size大于HashTable的扩容阈值，则进行扩容
resize();
afterNodeInsertion(evict);
return null;
}
resize方法
整个resize主要分成两个大的模块，第一个是扩容：计算出新的table的大小和新的阈值，第二个就是迁移：将原有table里面的Node重新计算迁移后槽的位置，并迁移。
第一大块扩容的主要思路是：
- 判断当前的table里面的size是否大于0，如果大于0的话，就会判断当前的table里面的size是否超过了最大值，如果超过最大值，就不会再扩容，如果没有超过的话，就会将原有的size扩大原来的两倍，并且判断扩容之后的size是否大于最大值，如果超过最大值就按照最大值来扩容。
- 如果当前table里面的size等于0的话，并且当前table里面的阈值大于0的时候，就会将原有的阈值设置为新的table的size大小。
- 如果两个条件都不满足的话，则会对新的table设置默认的size（16），和默认的阈值（16 * 0.75）
- 如果这个时候新的table的阈值为空，则会重新计算新的阈值
其实由此可以看得出来，扩容的主要思想就是，只要没有超过定义的最大值，那么每次扩容都是按照两倍的大小来扩容
代码如下：
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
// 判断现在的table的size是否大于0，如果大于0了才进行扩容操作
if (oldCap >= MAXIMUM_CAPACITY) {
// 如果现在table的size已经大于了最大容量，则不在扩容，任由table去碰撞
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 将新的table的size变成原有的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 如果新扩充的tablesize小于最大容量的话，并且现在的table的size大于默认的初始容量的话，
// 就会将新的table的阈值扩充为原来的两倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
// 如果现在的table的size等于0，并且现在的table的阈值大于0，
// 就将新的table的size大小设置成和现在的table阈值一样
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 如果都不是的话，则按照默认大小设置
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// 如果新的table的阈值等于0的话，则计算出新的阈值
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
第二大块迁移的主要思路是：
首先了解一点，在HashMap中确定槽的位置是通过Key的Hash值和table的size - 1做按位与运算得到的（(size - 1) & hash）
其次了解的第二点是，HashMap的容量始终为2的幂次
所以有个十分有意思的现象就是：在扩容的时候，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置，如图所示：
所以在扩容迁移元素的时候，不需要重新计算hash值，直接判断新增的高位bit是0还是1就好了。如果是0则不需要移动，如果是1则移动到原索引+oldCap的槽位置
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
// 循环遍历table
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
// 如果不是链表，就直接放到新计算出的槽
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 不需要迁移的链表定义
Node<K,V> loHead = null, loTail = null;
// 需要迁移的链表定义
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
// 循环遍历链表
next = e.next;
if ((e.hash & oldCap) == 0) {
// 判断链表是否需要迁移，如果为0则不需要迁移，加入不需要迁移的链表
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
// 不为0的时候需要迁移，加入需要迁移的链表
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) {
// 将需要迁移的链表放入（原来索引 + oldCap）的槽
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
get方法
get方法的大致思路是：
- 判断现在HashMap里面的table是否为空，以及要获取的key对应的槽是否为空，如果为空，就直接返回null；
- 如果都不为空，就判断槽里面的第一个node是不是想要找的key，如果是直接返回
- 如果第一个不是，就判断node节点是不是树节点，如果是，就直接去红黑树里面查找
- 如果也不是树节点，那就在链表里面循环查找
代码如下：
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 判断table是否为空，以及想要查找的key所对应的槽是否为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 判断这个槽的第一个节点是不是对应的这个key
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
// 判断这个槽的第一个节点是不是树节点
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
// 如果不是树节点，那么就用链表遍历
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
和JDK1.7的对比
- JDK1.7和JDK1.8最明显的一点是，插入链表的时候，在JDK1.7的时候，HashMap插入链表是采用的头插法，而在JDK1.8，HashMap插入链表采用的是尾插法，之所以这么改变的原因是因为，头插法的链表在HashMap的resize()过程中可能因为多线程导致的逆序，让链表形成死循环。
- 在JDK1.7的HashMap中，HashMap的数据结构是数组 + 单向链表，在JDK1.8的HashMap中，采用的是数组 + 单链表 + 红黑树的数据结构。
- 在resize()过程中，JDK1.7和JDK1.8的差别主要在迁移时计算新的索引的位置，JDK1.7时，是重新计算Key的hash值，然后用(size - 1) & hash得到新的索引位置，而JDK1.8时，是采用判断高一个bit位的位值，如果高一位的位值是0那么索引位置就不变，如果是1那么就用原来的HashMap的size大小加上原有的索引位置（原索引+oldCap），这么改变的原因是为了降低rehash带来的开销。
关于HashMap的一些细节总结：
1. 在HashMap中链表在什么时候会转化成红黑树？
在put里面可以看到
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
这个表示着链表在大于等于7个的时候，会将链表转化成为红黑树，在网络上的回答里面也大多是这样说的，但是还有一个细节要注意，在转换红黑树的时候，会去判断你当前HashMap的大小，如果当前HashMap的大小小于64的时候，会直接帮当前的HashMap扩容，而不是先扩容，在HashMap里面将链表转化成为红黑树的的注释是这样：
Replaces all linked nodes in bin at index for given hash unless table is too small, in which case resizes instead.
这句话的大概意思是，会替换所有的链表节点，除非当前的表太小了，这样将会调整大小
2. 在HashMap中为什么容量要是2的幂次方？
第一点：在put的时候，如果直接对长度进行取模，那么运算的消耗比较大，所以选择了与（长度 - 1）的&运算，而如果HashMap的容量不是2的幂次方，那么会使原本需要分散的数据，分散不均匀，加剧了HashMap的碰撞
第二点：在HashMap的resize过程中，因为长度是2的幂次方，所以在迁移节点的时候，不需要重新计算节点对应槽的下标值，而如果不采用2的幂次方的长度的话，每次都需要重新计算对应节点的下标值，增加了性能的消耗
3. HashMap的特性？
第一点：键值对(key - value)，在HashMap中所有的数据都是通过键值对来进行存储，同时，HashMap说明了无论是key还是value都是可以为null的。
第二点：分散，在HashMap中所有数据的存储都是分散的，所有数据的存储的位置都和插入顺序无关，而且随着时间的推移，节点可能移动。
