前段时间我去面试Java Leader岗，真实地感受到现在的技术面试已经“卷”到了新高度。尤其是像 HashMap 这种老生常谈的问题，几乎每家公司都会问，但问法早已经不是“说一说HashMap的原理”那么简单了。
1、HashMap 头插法，为什么会造成链表环？
在多线程的情况下，线程 1 的业务触发 HashMap 扩容，此时线程 2 的业务也在进行也触发了 HashMap 的扩容，这时就会出现以下的情形。以下来分解：
step1： 线程 T1 扩容 HashMap，遍历链表第一个元素A，A 节点下一个节点是 B，B 后面就结束了，即A->B->null。
由于 haspmap 是没有锁的，现在假设此时线程 T2 抢到了资源，线程 T1 被挂起了。可能有人会问为什么 T1 不能执行完，而会被 T2 给抢占了资源。因为这里只是假设极限情况，当然真实多线程的情况下并不是必然是这种情况，但这种情况肯定是会发生的。
step2：此时线程 T2 进行 HashMap 的扩容，线程 T2 下当前节点是 A，下一节点是 B，扩容是头插法所以先在头入 A，再到头上插入 B，最后就是 B->A->null。
step3：此时 T2 已经扩容结束，T1占用到了资源开始执行扩容，切换到 T1 的上下文，当时 T1 线程的当前节点 变量的值是A，A的成员变量 next (下一个节点)的值是 B。程序进入第一次循环也就是第二次循环的当前节点是 B，读取链表中的 B 时，此时链表是 T2 扩容后的链表，结构为 B->A，此时 B 的 next 发现不是 null 而是 A，发现此时 B 后面还有节点并不是 nulll，那么扩容程序继续执行，发现 B 后面是 A 节点，所以扩容成为 A->B->A。
step4：此时就变成了 A 下一节点是 B，B 下一节点又是 A，就形成了链表环。
2. HashMap的底层数据结构是什么？
答案：
JDK 1.7 及之前的HashMap使用的数组+链表的结构，插入时使用头插法。
JDK 1.8 之后的 HashMap 使用的数组+链表/红黑树的结构，插入时使用头插法。
以下是jdk1.7与jdk1.8中HashMap的区别：
JDK1.7 及之前
JDK1.7 及之前的 HashMap 由 Entry 数组组成，Entry 类是 HashMap 中存储键值对的类。Entry 类包含 key、value 和 next 三个属性。key 是键，value 是值，next 是指向下一个 Entry 对象的指针，出现 hash 冲突存放到链表中。具体源码是通过 put() 方法实现的。
put() 方法的实现如下：
public V put(K key, V value) {
// 如果哈希表为空，则对其进行申请数组空间
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
// 如果 key 为 null，则将其放入 null 键的特殊位置
if (key == null) {
return putForNullKey(value);
}
// 计算 key 的哈希值
int hash = hash(key);
// 根据哈希值和哈希表的长度计算索引位置
int i = indexFor(hash, table.length);
// 遍历索引位置上的链表，寻找 key
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
// 如果 key 相同，则更新 value 并返回旧值
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
// 如果 key 不存在，则添加一个新的链表成员
modCount++;
addEntry(hash, key, value, i);
return null;
}
put() 方法首先计算 key 的 hash 值，然后定位到数组索引位置。如果数组索引位置上已经存在 Entry 对象，则判断 key 是否相同。如果相同则直接覆盖value，否则添加到链表中。如果数组索引位置上不存在 Entry 对象，则直接添加到数组中。
链表的具体实现如下：
static class Entry<K, V> implements Map.Entry<K, V> {
final int hash;
final K key;
V value;
Entry<K, V> next;
Entry(int hash, K key, V value) {
this.hash = hash;
this.key = key;
this.value = value;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Entry<?, ?> entry = (Entry<?, ?>) o;
return hash == entry.hash &&
Objects.equals(key, entry.key) &&
Objects.equals(value, entry.value);
}
@Override
public int hashCode() {
return Objects.hash(hash, key, value);
}
@Override
public String toString() {
return key + "=" + value;
}
}
链表的每个元素是一个 Entry 对象，Entry 对象包含 key、value、hash 和 next 四个属性。key 是键，value 是值，hash 是 key 的 hash 值，next 是指向下一个 Entry 对象的指针。
当 HashMap 出现 hash 冲突时，会将新的 Entry 对象添加到链表的尾部。链表的查询性能较差，当链表长度过长时，会影响 HashMap 的查询性能。
JDK1.8 及之后
JDK1.8后采用 数组+链表+红黑树 结构。数组是主存储结构（桶数组），链表解决哈希冲突，当链表长度>8且数组长度≥64时，链表转为红黑树。
此阶段就要回答到红黑树，有问的细的就会问什么条件下链表会转为红黑树。另外就是要回答到 JDK1.7 使用的是头插法，jdk1.8 使用的是尾插法。HashMap 由 Node 数组组成，出现 hash 冲突存放到链表中同时满足条件的情况下会生成红黑树。具体源码是通过 put() 方法实现的。
put() 方法的实现如下：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 获取哈希表
Node<K,V>[] tab = table;
// 如果哈希表为空或长度为0，则进行扩容
if (tab == null || tab.length == 0) {
tab = resize();
}
// 计算索引位置
int n = tab.length;
int i = (n - 1) & hash;
// 如果索引位置上的节点为空，则添加一个新的节点
Node<K,V> p = tab[i];
if (p == null) {
tab[i] = newNode(hash, key, value, null);
} else {
// 如果索引位置上的节点存在，则遍历链表，寻找 key 相同的节点
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) {
// 如果索引位置上的节点是红黑树节点，则调用红黑树的 putTreeVal() 方法添加新的节点
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
} else {
// 如果索引位置上的节点是链表节点，则遍历链表，寻找 key 相同的节点
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 如果没有找到 key 相同的节点，则在链表尾部添加一个新的节点
p.next = newNode(hash, key, value, null);
// 如果链表长度超过阈值，则将链表转换为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) {
treeifyBin(tab, hash);
}
break;
}
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
// 如果找到 key 相同的节点，则停止遍历
break;
}
p = e;
}
}
if (e != null) { // 找到 key 相同的节点
// 获取旧值
V oldValue = e.value;
// 如果只有 key 不存在才添加新的节点，则仅当旧值为 null 时才更新值
if (!onlyIfAbsent || oldValue == null) {
e.value = value;
}
// 调用 afterNodeAccess() 方法更新节点的访问时间
afterNodeAccess(e);
return oldValue;
}
}
// 添加新的节点后，更新 HashMap 的大小和修改次数
++modCount;
if (++size > threshold) {
resize();
}
// 调用 afterNodeInsertion() 方法更新节点的插入状态
afterNodeInsertion(evict);
return null;
}
put() 方法在添加元素时，会先判断数组索引位置上是否已经存在 Node 对象。如果已经存在，则判断 key 是否相同。如果相同则更新 value，否则添加到链表中。
如果链表长度超过阈值，则将链表转换为红黑树。阈值的默认值是 8。
treeifyBin() 方法的实现如下：
final void treeifyBin(Node<K,V>[] tab, int hash) {
// 如果哈希表为空或长度小于 MIN_TREEIFY_CAPACITY，则进行扩容
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) {
resize();
} else if ((e = tab[index = (n - 1) & hash]) != null) {
// 获取索引位置上的节点
TreeNode<K,V> hd = null, tl = null;
// 遍历链表，将每个节点转换为红黑树节点
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null) {
hd = p;
} else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
// 将转换后的红黑树节点添加到哈希表中
if ((tab[index] = hd) != null) {
hd.treeify(tab);
}
}
}
treeifyBin() 方法首先判断链表的长度是否超过阈值。如果超过阈值，则将链表的第一个元素作为红黑树的根节点。
然后，将链表中的所有元素添加到红黑树中。
最后，将红黑树的根节点添加到数组中。
这样，当 HashMap 出现 hash 冲突存放到链表中同时满足条件的情况下，会将链表转换为红黑树，提高查询性能。
3.为什么 jdk 之前会使用头插法，后面调整为尾插法？
答案：
在 JDK 1.7 及之前的版本中，HashMap 在扩容时采用头插法用于将新节点插入到链表中 ，而不是尾插法。这样设计的原因主要有以下几点：
HashMap本身不是线程安全的，它的设计目标是在 单线程 下提供高性能的键值存储。JDK 1.7 的头插法在单线程下没有问题，只有在多线程并发扩容时才会出现链表环。- 插入效率高： 头插法只需要修改一个指针（新节点的
next指向旧头节点），不需要遍历整个链表，时间复杂度是 O(1)。 - 实现简单： 头插法的代码更简洁，不需要维护尾指针，适合快速构建链表结构。
从 JDK 1.8 开始，HashMap 改用了尾插法，主要是为了：
- 避免死循环：尾插法不会反转链表，即使并发修改，也不会出现
next指针错乱导致的环。 - 并发安全性提升： 在多线程环境下，头插法更容易导致链表结构混乱或死循环。尾插法更稳定，尤其在 resize 时。
- 配合红黑树转换： JDK 1.8 引入了链表转红黑树的机制，尾插法可以保持节点的插入顺序，有利于后续的树化操作。
4. 为什么 haspmap的数组长度总是2的n次幂？
答案：
HashMap 的数组长度总是 2 的 n 次幂，原因有三：
- 提高性能：
hash % length可用hash & (length - 1)代替，按位与比取模快。 - 均匀分布：2^n 的长度能充分利用二进制低位，减少哈希冲突。
- 扩容优化：扩容时元素要么留原位，要么移动到“原位+旧容量”，计算简单高效。
