Java最全Java-从-Map-到-HashMap-的一步步实现，看这篇足矣了！，一年后斩获腾讯T3

最后

分享一些系统的面试题，大家可以拿去刷一刷，准备面试涨薪。

这些面试题相对应的技术点：

• JVM
• MySQL
• Mybatis
• MongoDB
• Redis
• Spring
• Spring boot
• Spring cloud
• Kafka
• RabbitMQ
• Nginx
• …

大类就是：

• Java基础
• 数据结构与算法
• 并发编程
• 数据库
• 设计模式
• 微服务
• 消息中间件

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict);
//onlyIfAbsent 如果当前位置已存在一个值，是否替换，false是替换，true是不替换
evict // 钩子函数的参数，LinkedHashMap 中使用到，HashMap 中无意义。

2.3.1 putVal 的流程分析

其实 putVal() 流程的函数非常的明了。这里挑了几个关键步骤来引导。

是否第一次插入，true 调用 resizer() 进行调整，其实此时 resizer() 是进行完整的初始化，之后直接赋值给对应索引的位置。

if ((tab = table) == null || (n = tab.length) == 0) // 第一次 put 操作， tab 没有分配内存，通过 redize() 方法分配内存，开始工作。
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);

如果链表已经转化为树，则使用树的插入。

else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

用遍历的方式遍历每个 Node，如果遇到键相同，或者到达尾节点的next 指针将数据插入，记录节点位置退出循环。若插入后链表长度为 8 则调用 treeifyBin() 是否进行树的转化 。

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;
}

对键重复的操作：更新后返回旧值，同时还取决于onlyIfAbsent，普通操作中一般为 true，可以忽略。

if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); //钩子函数，进行后续其他操作，HashMap中为空，无任何操作。
return oldValue;
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;

后续的数据维护。

2.3.2 modCount 的含义

fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。一种多线程错误检查的方式，减少异常的发生。 一般情况下，多线程环境 我们使用 ConcurrentHashMap 来代替 HashMap。

2.4 resize() 函数

HashMap 扩容的特点：默认的table 表的大小事 16，threshold 为 12。负载因子 loadFactor .75，这些都是可以构造是更改。以后扩容都是 2 倍的方式增加。 至于为何是0.75 代码的注释中也写了原因，对 Hash函数构建了泊松分布模型，进行了分析。

2.4.1 HashMap 预定义的一些参数

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 HashMap 的默认大小。 为什么使用 1 <<4
static final int MAXIMUM_CAPACITY = 1 << 30; // 最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f; // 加载因子，扩容使用

static final int UNTREEIFY_THRESHOLD = 6;// 树结构转化为链表的阈值
static final int TREEIFY_THRESHOLD = 8; // 链表转化为树结构的阈值
static final int MIN_TREEIFY_CAPACITY = 64; // 链表转变成树之前，还会有一次判断，只有数组长度大于 64 才会发生转换。这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。

// 定义的有关变量
int threshold; // threshold表示当HashMap的size大于threshold时会执行resize操作

这些变量都是和 HashMap 的扩容机制有关，将会在下文中用到。

2.4.2 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) { // 如果旧的表长度大于 1 << 30;
threshold = Integer.MAX_VALUE; // threshold 设置 Integer 的最大值。也就是说我们可以插入 Integer.MAX_VALUE 个数据
return oldTab; // 直接返回旧表的长度，因为表的下标索引无法扩大了。
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && //
oldCap >= DEFAULT_INITIAL_CAPACITY) //新表的长度为旧表的长度的 2 倍。
newThr = oldThr << 1; // double threshold 新表的阈值为同时为旧表的两倍
}
else if (oldThr > 0) // public HashMap(int initialCapacity, float loadFactor) 中的 this.threshold = tableSizeFor(initialCapacity); 给正确的位置
newCap = oldThr;
else { // zero initial threshold signifies using defaults ，如果调用了其他两个构造函数，则下面代码初始化。因为他们都没有对其 threshold 设置，默认为 0，
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) { // 修正 threshold，例如上面的 else if (oldThr > 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];

当扩容完毕之后，自然就是将原表中的数据搬到新的表中。下面代码完成了该任务。

if (oldTab != null) { //
for (int j = 0; j < oldCap; ++j) {
…
}
}

如何正确的，快速的扩容调整每个键值节点对应的下标？第一种方法：遍历节点再使用 put() 加入一遍，这种方法实现，但是效率低下。第二种，我们手动组装好链表，加入到相应的位置。显然第二种比第一种高效，因为第一种 put() 还存在其他不属于这种情况的判断，例如重复键的判断等。所以 JDK 1.8 也使用了第二种方法。我们可以继续使用e.hash & (newCap - 1)找到对应的下标位置,对于旧的链表，执行e.hash & (newCap - 1) 操作，只能产生两个不同的索引。一个保持原来的索引不变，另一个变为 原来索引 + oldCap(因为 newCap 的加入产生导致索引的位数多了 1 位，即就是最左边的一个，且该位此时结果为 1，所以相当于 原来索引 + oldCap)。所以可以使用 if ((e.hash & oldCap) == 0) 来确定出索引是否来变化。因此这样我们就可以将原来的链表拆分为两个新的链表，然后加入到对应的位置。为了高效，我们手动的组装好链表再存储到相应的下标位置上。

oldCap = 16
newCap = 32
hash : 0001 1011
oldCap-1 : 0000 1111
结果为 : 0000 1011 对应的索引的 11

e.hash & oldCap 则定于 1,则需要进行调整索引
oldCap = 16
hash : 0001 1011
newCap-1 : 0001 1111
结果为 : 0001 1011
相当于 1011 + 1 0000 原来索引 + newCap
for (int j = 0; j < oldCap; ++j) // 处理每个链表

特殊条件处理

Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null) // 该 链表只有一个节点，那么直接复制到对应的位置，下标由 e.hash & (newCap - 1) 确定
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; // 构建 原来索引 + oldCap 位置 的链表需要的指针
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;
}
}

到此 resize() 方法的逻辑完成了。总的来说 resizer() 完成了 HashMap 完整的初始化，分配内存和后续的扩容维护工作。

2.5 remove 解析

public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}

将 remove 删除工作交给内部函数 removeNode() 来实现。

final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) { // 获取索引，
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) // 判断索引处的值是不是想要的结果
node = p;
else if ((e = p.next) != null) { // 交给树的查找算法
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do { // 遍历查找
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode) //树的删除
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p) // 修复链表，链表的删除操作
tab[index] = node.next;
else
p.next = node.next;
++modCount;
–size;
afterNodeRemoval(node);
return node;
}
}
return null;
}

三、 HashMap 从链表到红黑树的转变

如果链表的长度（冲突的节点数）已经达到8个，此时会调用 treeifyBin() ，treeifyBin() 首先判断当前hashMap 的 table的长度，如果不足64，只进行resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树。 在源码还有这样的一个字段。

static final int UNTREEIFY_THRESHOLD = 6; // 这样表明了从红黑树转化为链表的阈值为 6，为何同样不是 8 那？ 如果插入和删除都在 8 附近，将多二者相互转化将浪费大量的时间，对其性能影响。 如果是的二者转化的操作不平衡，偏向一方，则可以避免此类影响。

3.1 红黑树的数据结构

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // 删除后需要取消链接，指向前一个节点（原链表中的前一个节点）
boolean red;
}

因为 继承了 LinkedHashMap.Entry<K,V> ，所以存储的数据还是在Entry 中：

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;
}
}

3.2 承上启下的 treeifyBin()

treeifyBin() 决定了一个链表何时转化为一个红黑树。 treeifyBin() 有两种格式：

final void treeifyBin(Node<K,V>[] tab, int hash);
final void treeify(Node<K,V>[] tab);
final void treeifyBin(Node<K,V>[] tab, int hash) { // 简单的 Node 修改为 TreeNode，同时维护了 prev 属性。
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); // 真正生成红黑树的
}
}
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
return new TreeNode<>(p.hash, p.key, p.value, next);
} // 实现 Node 链表节点到 TreeNode 节点的转化。

下面函数真正实现了链表的红黑树的转变。首先构建一个标准查询二叉树，然后在标准查询二叉树然后调整为一个红黑树。而 balanceInsertion() 实现了调整。

/**

• Forms tree of the nodes linked from this node.
  */
  final void treeify(Node<K,V>[] tab) {
  TreeNode<K,V> root = null;
  for (TreeNode<K,V> x = this, next; x != null; x = next) {
  next = (TreeNode<K,V>)x.next;
  x.left = x.right = null;
  if (root == null) { // 第一次转化过程，将链表的头节点作为根节点。
  x.parent = null;
  x.red = false; // 红黑树的定义 根节点必须为黑色
  root = x;
  }
  else {
  K k = x.key;
  int h = x.hash;
  Class<?> kc = null;
  for (TreeNode<K,V> p = root;😉 {
  int dir, ph;
  K pk = p.key;
  if ((ph = p.hash) > h) 通过 Hash 的大小来确定插入顺序
  dir = -1; // dir 大小顺序的标识
  else if (ph < h)
  dir = 1;
  else if ((kc == null && //当 两个 Hash 的值相同，进行特殊的方法，确定大小。
  (kc = comparableClassFor(k)) == null) || // Returns x’s Class if it is of the form "class C implements Comparable ", else null. 如果 key类的 源码书写格式为 C implement Comparable 那么返回该类类型 C, 如果间接实现也不行。 如果是 String 类型，直接返回 String.class
  (dir = compareComparables(kc, k, pk)) == 0) // ((Comparable)k).compareTo(pk)); 强制转换后进行对比，若 dir == 0,则 tieBreakOrder()，继续仲裁
  dir = tieBreakOrder(k, pk); // 首先通过二者的类类型进行比较，如果相等的话，使用 (System.identityHashCode(a) <= System.identityHashCode(b) 使用原始的 hashcode，不是重写的在对比。

TreeNode<K,V> xp = p; // 遍历的，上一个节点
if ((p = (dir <= 0) ? p.left : p.right) == null) { //通过 dir，将 p 向下查找，直到 p 为 null，找到一个插入时机
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
root = balanceInsertion(root, x); //进行二叉树的调整
break;
}
}
}
}
moveRootToFront(tab, root);
}

3.3 将一个二叉树转化为红黑树的操作-balanceInsertion()

当红黑树中新增节点的时候需要调用balanceInsertion方法来保证红黑树的特性。 如果想要了解红黑树的插入过程那么必须对红黑树的性质有一个较为清晰的了解。

红黑树的性质：

1. 每个结点或是红色的，或是黑色的

2. 根节点是黑色的

3. 每个叶结点（NIL）是黑色的

4. 如果一个节点是红色的，则它的两个儿子都是黑色的。

5. 对于每个结点，从该结点到其叶子结点构成的所有路径上的黑结点个数相同。

static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
x.red = true; // 插入的子节点必须为 red
for (TreeNode<K,V> xp, xpp, xppl, xppr;😉 { x 当前处理节点 xp父节点 xpp祖父节点 xppl祖父左节点 xppr 祖父右节点
if ((xp = x.parent) == null) { // 如果 当前处理节点为根节点，满足红黑树的性质，结束循环
x.red = false;
return x;
}
else if (!xp.red || (xpp = xp.parent) == null)
return root;
if (xp == (xppl = xpp.left)) {
if ((xppr = xpp.right) != null && xppr.red) {
xppr.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
if (x == xp.right) {
root = rotateLeft(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateRight(root, xpp);
}
}
}
}
else {
if (xppl != null && xppl.red) {
xppl.red = false;
xp.red = false;
xpp.red = true;

最后

金三银四马上就到了，希望大家能好好学习一下这些技术点

学习视频：

大厂面试真题：

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

null) {
xpp.red = true;
root = rotateRight(root, xpp);
}
}
}
}
else {
if (xppl != null && xppl.red) {
xppl.red = false;
xp.red = false;
xpp.red = true;

最后

金三银四马上就到了，希望大家能好好学习一下这些技术点

学习视频：

[外链图片转存中…(img-ZViBkfPU-1715307492750)]

大厂面试真题：

[外链图片转存中…(img-knqLYnZk-1715307492750)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取