引言
在Java集合中，HashMap的重要性不言而喻，作为一种存储键值对的数据结构，它在日常开发中有着非常多的应用场景，也是面试中的高频考点，本篇文章就来分析一下HashMap集合中的put方法。
HashMap底层数据结构
先来了解一下HashMap底层的数据结构，它实质上是一个散列表，在数据结构课程中，我们应该都学习过散列表，它是通过关键码值而直接进行访问的一种数据结构，比如存储这样的一个序列：5,12,7,6,1,3。我们首先需要设定一个hash函数，通过该函数就能够定位每个元素存储的位置，比如hash函数为 H(k) = k % 6，那么每个元素的存储位置即为：1,0,1,0,1,3，此时问题就出现了，有几个元素的存储位置计算后发现是一样的，而一个位置不可能存放两个值，这就是hash冲突。
解决哈希冲突的方式有很多：
- 线性探测法
- 伪随机数法
- 链地址法
若是采用较为简单的线性探测法，则将产生冲突的元素向后移动一个位置，若是仍然有冲突，则继续后移一位，由此可得每个元素的存储位置：
在HashMap中，它的设计当然是要精妙很多的，查阅其源码：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}我们发现了这样的一个内容类，它是一个Node节点，由此，我们可以猜测，HashMap对于冲突的解决办法采用的是链地址法，那么HashMap数据的真正存放位置是在哪呢？
transient Node<K,V>[] table;就是这样的一个Node数组。
put方法的执行流程
我们直接通过一个程序来理解HashMap中put方法的执行流程，在put方法中，HashMap需要经历初始化、存值、扩容、解决冲突等等操作：
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("name", "zs");
map.put("age", "20");
map.put("name", "lisi");
map.forEach((k, v) -> {
System.out.println(k + "--" + v);
});
}这段程序的运行结果我们都知道是name--lisi age -- 20，那为什么是这个结果呢？源码能够告诉我们答案。
首先执行第一行代码，调用HashMap的无参构造方法：
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}在构造方法中，只是设置了一个loadFactor的成员变量，它表示的是hash表的负载因子，默认值为0.75，至于这个负载因子是什么，我们后面再说。
接下来程序会执行put方法：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}put方法又调用了putVal方法，并传入了key的hash，key，value等等参数，所以先来计算key的hash：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}这个hash是用来计算插入位置的，我们放到后面说，计算完key的hash后，它将调用putVal方法：
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;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}该方法的前三行先定义了一个Node类型的数组和一个变量，并判断类成员中的table是否为空，前面我们已经说到，这个table就是真正来存储数据的数组，它的初始值肯定为空，所以会触发resize方法：
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
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;
@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) {
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) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
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;
}这个resize方法其实是相当复杂的，但我们捡出重要的代码来看，因为table的初始值为null，所以一定会进入下面的分支：
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}它设置了两个变量的值，newCap = 16，newThr = 0.75 * 16 = 12，其中newCap就是本次需要创建的table数组的容量，而newThr就是实际只能存储的容量大小。
对于一个散列表，如果让其每个位置都占满元素，那么一定是已经产生大量的冲突了，但若是只让小部分位置存储元素，又会浪费散列表的空间，由此，前辈们经过大量的计算，得出散列表的总容量 * 0.75之后的值是散列表最合适的存储容量，这个0.75就被称为散列表中的负载因子。所以，HashMap在第一次调用put方法时会创建一个总容量为16的Node类型数组（前提是调用无参构造方法），但实际上只有12的容量可以被使用，当第13个元素插入时，就需要考虑扩容。
接下来就是初始化table数组：
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;通过调用resize方法，我们就获得了一个容量为16的Node数组，紧接着就执行：
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);还记得这个hash变量吗？它就是前面求得的key的hash值，通过n（table数组的长度，即：16）减1并与hash值做一个与运算，即可得到该数据的存储位置，它类似于文章开篇提到的hash函数 H(k) = k % 6，它做的也是这个操作，hash % n。需要注意，若是求模操作中，除数是2的幂次，则求模操作可以等价于与其除数减1的与操作，即：hash & (n - 1)，因为&操作的效率是要高于求模运算的，所以HashMap会将n设计为2的幂次。
求得数据需要插入的位置后，就需要判断当前位置是否有元素，现在table数组中没有任何数据，所以第一次判断一定是null，符合条件，执行代码：tab[i] = newNode(hash, key, value, null);，创建了一个节点，并存入hash值，key、value及其指针域：
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}最后执行：
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);判断当前容量size是否超过了阈值threshold，若是超过了，还需要调用resize方法进行扩容。
到这里，第一个数据name:zs就插入成功了。
第二个数据age:20在这里就不作分析了，它和name的插入流程是一样的，我们分析一下第三个数据name:lisi的插入，这里涉及到了一个key重复的问题，来看看HashMap是如何处理的。
首先仍然是调用putVal方法，并计算key的hash值，然后判断当前table是否为空，这次table肯定不为空，所以直接走到：
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);仍然通过(n - 1) & hash计算数据的插入位置，结果发现要插入的位置已经有元素了，就是name:zs，此时就产生了冲突，执行：
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;现在的p就是name:zs，通过p的hash与当前数据key的hash比较，发现hash值相同，继续比较p的key，即：name与当前数据的key是否相同，发现仍然相同，此时就将p交给e管理，最后执行：
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}此时e不为null，所以将e中的value值设置为当前数据的value值，由此，HashMap便成功将key为name的值修改为了lisi，并返回了原值zs。
总结
综上所述，我们能够得到以下结论：
- HashMap的总容量一定是2的幂次方，即使通过构造函数传入一个不是2的幂次方的容量，HashMap也会将其扩充至与其最接近的2的幂次方的值；比如传入总容量为10，则HashMap会自动将容量扩充至16
- 若是调用HashMap的无参构造方法，则将在第一次执行put方法时初始化一个总容量为16，实际可用容量为12的Node数组
- 当实际容量超过阈值时，HashMap会进行扩容，扩容至原容量的2倍
- HashMap的put方法执行流程：首先判断当前table是否为空，若为空，则初始化，若不为空，则根据key的hash计算得到插入位置，再判断该位置是否有元素，若无元素，则直接插入，若有元素，则判断原位置数据的hash值与待插入数据的hash值是否相同，若相同，则继续比较值，若值不同，则创建一个新的Node节点，并使用尾插法将其插入到原数据的节点后面形成链表，若值相同，则采用待插入数据的值覆盖原数据的值，并返回原数据的值
- HashMap采用链地址法解决hash冲突，所以当某个链表的长度大于8，并且table数组的长度大于64，则当前链表会被转换为红黑树，若table数组的长度尚未达到64，则进行扩容；当链表长度小于6，则会将红黑树转回链表
- 因为HashMap会根据key的hash值计算插入位置，所以key的数据类型一定要重写hashCode方法，否则会出现两个相同的key结果hash值不相同的情况，也需要重写equals方法，否则equals方法将比较的是地址值
