1.数据结构
如上图所示，HashMap底层的数据结构主要是数组 + 链表 + 红黑树。其中当链表的长度大于等于8时，链表会转化成红黑树，当红黑树的大小小于等于6时，红黑树会转化成链表。图中左边竖着的是HashMap的数组结构，数组的元素可以是单个Node，也可以是链表或红黑树，比如数组下标索引为2的位置就是一个链表，下标索引为9的位置对应的是红黑树。
源码
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
//初始容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子默认值
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//桶上的链表长度大于等于8时，链表转化成红黑树
static final int TREEIFY_THRESHOLD = 8;
//桶上的红黑树大小小于等于6时，红黑树转化成链表
static final int UNTREEIFY_THRESHOLD = 6;
//当数组容量大于64时，链表才会转化成红黑树
static final int MIN_TREEIFY_CAPACITY = 64;
//记录迭代过程中HashMap结构是否发生变化，如果有变化，迭代时会fail-fast
transient int modCount;
//HashMap的实际大小，可能不准(因为当拿到这个值的时候，可能该值又发生了变化)
transient int size;
//存放数据的数组
transient Node<K,V>[] table;
/**
* 扩容的门槛，有两种情况
* 如果初始化时，给定数组大小的话，通过tableSizeFor方法计算，数组大小永远接近于2的幂次方，例如给定初始化大小19，实际上初始化大小为32，为2的5次方
* 如果是通过resize方法进行扩容，大小 = 数组容量 * 0.75
*/
int threshold;
//链表的节点
static class Node<K,V> implements Map.Entry<K,V> {
//红黑树的节点
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {......}
}源码解析
- HashMap允许null值，不同于HashTable，是线程不安全的。
- 影响因子(load factor)默认值是0.75，是均衡了时间和空间损耗计算出来的值，较高的值会减少空间开销(扩容减少，数组大小增长速度变慢)，但增加了查找成本(hash冲突增加，链表长度变长)，不扩容的条件是数组容量 > 需要的数组大小 / load factor。
- 如果HashMap需要储存很多数据时，建议HashMap的初始容量一开始就设置的足够大，这样可以防止扩容时所带来的性能影响。
- HashMap是非线程安全的，可以在外部加锁，或者通过Collections的synchronizedMap方法来实现线程安全，synchronizedMap的实现是在每个方法上加上了synchronized锁。
- 在迭代过程中，如果HashMap的结构被修改，会快速失败。
2.新增
新增key和value的源码如下所示。
源码
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
//入参hash为通过hash算法计算出来的值
//入参onlyIfAbsent为boolean类型，默认为false，表示即使key已经存在了，仍然会用新值覆盖原来的值，
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
//n表示数组的长度，i为数组索引下标，p为i位置的节点
Node<K,V> [] tab; Node<K,V> p;
int n, i;
//如果数组为空，使用resize方法初始化
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);
//如果当前索引位置有值，即常说的hash冲突
else {
//e为当前节点的临时变量
Node<K,V> e;
K k;
//如果key的hash和值都相等，直接把当前下标位置的Node值赋值给临时变量
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) {
//e = p.next表示从头开始，遍历链表
//p.next == null表明p是链表的尾节点
if ((e = p.next) == null) {
//把新节点放到链表的尾部
p.next = newNode(hash, key, value, null);
//当链表的长度大于等于8时，链表转红黑树
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//链表遍历过程中，发现有元素和新增的元素相等，结束循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//更改循环的当前元素，使p在遍历过程中一直往后移动
p = e;
}
}
//e != null说明新节点的新增位置已经找到
if (e != null) {
V oldValue = e.value;
//当onlyIfAbsent为false时，才会覆盖原值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//返回老值
return oldValue;
}
}
++modCount;
//如果HashMap的实际大小大于扩容的门槛，开始扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
}源码解析
- 先判断空数组有无初始化，没有的话则进行初始化。
- 如果通过key的hash能够直接找到值，跳转到6，否则跳转到3。
- 如果hash冲突，两种解决方案，链表或红黑树。
- 如果是链表，递归循环，把新元素追加到队尾。
- 如果是红黑树，调用红黑树新增的方法。
- 通过2、4、5将新元素追加成功后，再根据onlyIfAbsent判断是否需要覆盖。
- 判断是否需要扩容，需要扩容则进行扩容，否则结束新增流程。
3.链表的新增
链表的新增比较简单，把当前节点追加到链表的尾部，和LinkedList的追加实现是一样的。当链表长度大于等于8时，此时的链表就会转化成红黑树，转化的方法是treeifyBin，此方法有一个判断，当链表长度大于等于8，并且整个数组大小大于64时，才会转成红黑树，当数组大小小于6 时，只会触发扩容，不会转化成红黑树。
面试的时候，通常会问为什么是8，是因为链表查询的时间复杂度是O(n)，红黑树的查询复杂度是O(log(n))。在链表数据不多的时候，使用链表进行遍历也比较快，只有当链表数据比较多的时候，才会转化成红黑树。但红黑树占用的空间是链表的2倍，考虑到转化时间和空间损耗，所以需要定义出转化的边界值。设计这个边界值的时候，参考了泊松分布概率函数，链表各个长度的命中概率如下所示。
* 0: 0.60653066
* 1: 0.30326533
* 2: 0.07581633
* 3: 0.01263606
* 4: 0.00157952
* 5: 0.00015795
* 6: 0.00001316
* 7: 0.00000094
* 8: 0.00000006
当链表的长度为8的时候，出现的概率是0.00000006，不到千万分之一，所以说正常情况下，链表的长度不可能到达8，而一旦到达8时，肯定是hash算法出了问题，所以在这种情况下，为了让HashMap仍然有较高的查询性能，所以让链表转化成红黑树。使用HashMap时，几乎不会碰到链表转化成红黑树的情况，毕竟概率只有千万分之一。
4.红黑树的新增
红黑树新增节点过程的源码如下所示。
源码
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
//入参h为key的hash值
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
//找到根节点
TreeNode<K,V> root = (parent != null) ? root() : this;
//自旋
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
//p的hash值大于h，说明p在h的右边
if ((ph = p.hash) > h)
dir = -1;
//p的hash值小于 h，说明p在h的左边
else if (ph < h)
dir = 1;
//判断要放进去的key在当前树中是否已存在(通过equals来判断)
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
//自定义的Comparable不能用hashcode比较，需要用compareTo
else if ((kc == null &&
//得到key的Class类型，如果key没有实现Comparable就是null
(kc = comparableClassFor(k)) == null) ||
//当前节点pk和入参k不等
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
//找到和当前hashcode值相近的节点(当前节点的左右子节点其中一个为空即可)
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
//生成新的节点
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
//把新节点放在当前子节点为空的位置上
if (dir <= 0)
xp.left = x;
else
xp.right = x;
//当前节点和新节点建立父子、前后关系
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
/**
* balanceInsertion对红黑树进行着色或旋转，以达到更高的查找效率，着色或旋转的几种场景如下
* 着色:新节点总是为红色。如果新节点的父亲是黑色，则不需要重新着色，如果父亲是红色，那么必须通过重新着色或者旋转的方法，再次达到红黑树的5个约束条件
* 旋转:父亲是红色，叔叔是黑色时，进行旋转
* 如果当前节点是父亲的右节点，则进行左旋
* 如果当前节点是父亲的左节点，则进行右旋
*/
//moveRootToFront方法是把算出来的root放到根节点上
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
}源码解析
- 首先判断新增的节点在红黑树上是否已经存在，判断方法有两种，如果节点没有实现Comparable接口，使用equals进行判断，如果节点实现了Comparable接口，则使用compareTo进行判断。
- 新增的节点如果已经在红黑树上，直接返回，不在的话，判断新增节点是在当前节点的左边还是右边，左边值小，右边值大。
- 自旋递归第1步和第2步，直到当前节点的左边或者右边的节点为空时，停止自旋，当前节点即为新增节点的父节点。
- 把新增节点放到当前节点的左边或右边为空的位置，并为当前节点建立父子节点关系。
- 进行着色和旋转，流程结束。
5.查找
HashMap的查找主要分为两步，第一步是根据hash算法定位数组的索引位置，equals判断当前节点是否是需要寻找的key，是的话直接返回，否则继续第二步。第二步会判断当前节点有无next节点，有的话判断是链表类型，还是红黑树类型。分别走链表和红黑树不同类型的查找方法。链表查找的关键源码如下。
//采用自旋方式从链表中查找key
do {
//如果当前节点hash等于key的hash，并且equals相等，当前节点即是要找的节点
//当hash冲突时，通过equals方法来比较key是否相等
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
return e;
//否则，把当前节点的下一个节点拿出来继续寻找
} while ((e = e.next) != null);