导航：
目录
JDK1.7及之前版本，HashMap底层是“数组+单向链表”。
在JDK8中,HashMap底层是采用“数组+单向链表+红黑树”来实现的，使用红黑树主要是为了提高查询性能。数组用作哈希查找，链表用作链地址法处理冲突，红黑树替换长度为8的链表。
HashMap中，数组的默认初始容量为16，这个容量会以2的指数进行扩容。具体来说，当数组中的元素达到一定比例的时候HashMap就会扩容，这个比例叫做负载因子，默认为0.75。
自动扩容机制，是为了保证HashMap初始时不必占据太大的内存，而在使用期间又可以实时保证有足够大的空间。采用2的指数进行扩容，是为了利用位运算，提高扩容运算的效率。
数组每个元素存的是链表头结点地址，链地址法处理冲突，若链表的长度达到了8，红黑树代替链表。
put()方法的执行过程中,主要包含四个步骤：
其中，第3步又可以细分为如下三个小步骤：
1. 若元素的key与头节点的key一致，则直接覆盖头节点。
2. 若元素为树型节点，则将元素追加到树中。
3. 若元素为链表节点，则将元素追加到链表中。追加后，需要判断链表长度以决定是否转为红黑树。若链表长度达到8、数组容量未达到64，则扩容。若链表长度达到8、数组容量达到64，则转为红黑树。
哈希表处理冲突：开放地址法（线性探测、二次探测、再哈希法）、链地址法
key=value&(2^n-1) #结果相当于value%(2^n)，使用位运算只要是为了提高计算速度。例如当前数组容量是16，我们要存取18，那么就可以用18&15==2。相当于18%16==2.
put()里，计算key的部分源码：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { // 此处省略了代码 // i = (n - 1) & hash] if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { // 省略了代码 } }
计算value对应key的Hash运算：
key=value&(2^n-1）#结果相当于value%(2^n)。例如18&15和18%16值是相等的2^n-1和2^(n+1)-1的二进制除了第一位，后几位都是相同的。这样可以使得添加的元素均匀分布在HashMap的每个位置上，防止哈希碰撞。
例如15（即2^4-1）的二进制为1111，31的二进制为11111，63的二进制为111111，127的二进制为1111111。
0&(2^4-1)=0；0&(2^5-1)=0
16&(2^4-1)=0；16&(2^5-1)=16。所以扩容后，key为0的一部分value位置没变，一部分value迁移到扩容后的新位置。
1&(2^4-1)=1；1&(2^5-1)=1
17&(2^4-1)=1；17&(2^5-1)=17。所以扩容后，key为1的一部分value位置没变，一部分value迁移到扩容后的新位置。
用取余演示扩容：
如果觉得与运算有点难理解，我们可以用取余演示：
假设从16扩容到32：1%16=1,17%16=1；1%32=1,17%32=17。
1和17本来key都是1，扩容后1的key还是1，17的key变成17。这样原来key为1的value就均匀的散列在扩容后的哈希表里了（一部分value不变，一部分value移动到扩容后新位置）。
HashMap是线程不安全的，多线程环境下可能出现死循环问题、数据覆盖问题。
多线程下建议使用Collections工具类和JUC包的ConcurrentHashMap。
Collections.synchronizedMap(map);单线程扩容流程：
JDK7中，HashMap链地址法处理冲突时采用头插法，在扩容时依然头插法，所以链表里结点顺序会反过来。
假如有T1、T2两个线程同时对某链表扩容，他们都标记头结点和第二个结点，此时T2阻塞，T1执行完扩容后链表结点顺序反过来，此时T2恢复运行再进行翻转就会产生环形链表，即B.next=A; A.next=B，从而死循环。
JDK8 尾插法解决了死循环问题。
JDK8中，HashMap采用尾插法，扩容时链表节点位置不会翻转，解决了扩容死循环问题，但是性能差了一点，因为要遍历链表再查到尾部。
例如A——>B——>C要迁移，迁移时先移动头结点A，再移动B并插入A的尾部，再移动C插入尾部，这样结果还是A——>B——>C。顺序没变，扩容线程
HashMap非线程安全，如果两个并发线程插入的数据hash取余后相等，就可能出现数据覆盖。
线程A刚找到链表null位置准备插入时就阻塞了，然后线程B找到这个null位置插入成功。借着线程A恢复，因为已经判过null，所以直接覆盖插入这个位置，把线程B插入的数据覆盖了。
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)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) // 如果没有 hash 碰撞，则直接插入
tab[i] = newNode(hash, key, value, null);
}
modCount： HashMap的成员变量，用于记录HashMap被修改次数
put会执行modCount++操作，这步操作分为读取、增加、保存，不是一个原子性操作，也会出现线程安全问题。
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)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
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;
}
}
//put会执行modCount++操作，这步操作分为读取、增加、保存，不是一个原子性操作，也会出现线程安全问题。
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}