Java面试必备：通俗易懂的搞定HashMap源码，kafka面试题有什么用

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

HashMap的结构：

1.1 动态数组

我们先看最上层。

通过结构图我们看出，HashMap就是一个可以扩容的动态数组。考虑到扩容的需要，该动态数组有着以下属性：

• capacity：目前数组的长度。为了实现高效的扩容，其值总为2^n的形式。每次扩容后，n会加1，即整个数组的容量变为之前的2倍。该值初始默认值为16

• loadFactor：负载因子，默认值为 0.75。该值与threshold配合使用

• threshold：扩容的阈值，等于 capacity * loadFactor。即当数组内达到这么多元素时，会触发数组的扩容

1.2 数组元素

数组中的每个元素是一个Node，它的属性有：

• hash: 当前位置值的hash值

• key：当前位置的键

• value: 当前位置存储的值

• next;下一个Node

1.3 列表或者树

对于每个Node元素，我们发现它有一个next属性。而通过它，挂载到数组同一个位置的多个Node就组成了列表或者树。

在Java1.7阶段，是不存在树的，即挂载到数组同一个位置的多个Node通过next属性构成了一个单向链表。

而在Java1.8中，当单项链表中元素大于等于8时，单项列表会变为一棵树。该树为红黑树。该转化操作是由final void treeifyBin(Node<K,V>[] tab, int hash)函数实现的。

因为链表的查找时间复杂度为O(N)，而红黑树查找的时间复杂度为 O(logN)。因此，在数组的同一位置挂载的节点较多时，Java1.8的设计会降低时间复杂度。

2 初始化操作

---

HashMap的初始化操作非常简单，就是确定initialCapacity,loadFactor的初始值的过程。

平时，我们调用无参构造函数public HashMap()时，所有的值会采用默认值。即loadFactor=0.75。

如果我们传入initialCapacity,loadFactor，则会调用下面的方法。

public HashMap(int initialCapacity, float loadFactor) {

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal initial capacity: " +

initialCapacity);

if (initialCapacity > MAXIMUM_CAPACITY)

initialCapacity = MAXIMUM_CAPACITY;

if (loadFactor <= 0 || Float.isNaN(loadFactor))

throw new IllegalArgumentException("Illegal load factor: " +

loadFactor);

this.loadFactor = loadFactor;

this.threshold = tableSizeFor(initialCapacity);

}

但是有一点要注意，在进行初始化操作时，只是初始化了创建数组的相关参数，并没有真正创建动态数组。真正动态数组的创建是在第一次进行数据写入时引发的。

这样实际上是一种懒加载操作，防止了初始化后而不用的内存浪费。

3 数据写入操作

---

向HashMap中写入数据的过程，简单总结起来分为这么几步：

• 计算要插入数据的Hash值，并根据该值确定元素的插入位置（即在动态数组中的位置）

• 将元素放入到数组的指定位置

• 如果该数组位置之前没有元素，则直接放入

• 放入该位置后，数组元素超过扩容阈值，则对数组进行扩容

• 放入该位置后，数组元素没超过扩容阈值，写入结束

• 如果该数组位置之前有元素，则挂载到已有元素的后端

• 如果之前元素组成了树，则挂入树的指定位置

• 如果之前元素组成了链表

• 如果加入该元素链表长度超过8，则将链表转化为红黑树后插入

• 如果加入该元素链表长度不超过8，则直接插入

实际的操作要比这些复杂以下，我们直接结合源码进行分析。相关关键步骤我添加了注释。

// 供外部调用的方法

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; Node<K,V> p; int n, i;

// 这里如果发现动态数组为null则会初始化数组。因此第一次放入值时会在这里初始化数组

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length;

// 通过hash发现要放入的元素的数组位置为null，则直接把该元素放在这里即可

if ((p = tab[i = (n - 1) & hash]) == null)

tab[i] = newNode(hash, key, value, null);

else {

// 如果要放入的位置已经有元素了

Node<K,V> e; K k;

// 判断原位置第一个元素是否和新元素key完全一致

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;

}

}

// 这里说明新值和旧值的key完全相同，进行覆盖操作

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;

}

4 数据读取操作

---

相比于数据写入，数据读取操作要简单一些。总体过程总结为：

• 根据要取得key的值，hash出数组中的指定位置

• 取出指定位置的元素（这时，key的hash值是一样的）

• 如果key也完全一样，则返回该值，查找结束

• 如果key不一样，判断其后面挂载的是树还是列表

• 如果是树，按照树的方法查找

• 如果是列表，按照列表的方法查找

到达任何一步发现没有结果，则说明key在map中不存在，直接返回null即可。

代码和相关注释如下：

// 供外部调用的方法

public V get(Object key) {

Node<K,V> e;

return (e = getNode(hash(key), key)) == null ? null : e.value;

}

final Node<K,V> getNode(int hash, Object key) {

Node<K,V>[] tab; Node<K,V> first, e; int n; K k;

// 判断数组存在且不为空，否则直接返回null

if ((tab = table) != null && (n = tab.length) > 0 &&

(first = tab[(n - 1) & hash]) != null) {

if (first.hash == hash && // always check first node

// 第一个节点key与要查找的完全一致

((k = first.key) == key || (key != null && key.equals(k))))

return first;

if ((e = first.next) != null) {

// 第一个节点key与要查找的不一致

if (first instanceof TreeNode)

// 按照树的方法查找

return ((TreeNode<K,V>)first).getTreeNode(hash, key);

do {

// 按照列表方法查找

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

return e;

} while ((e = e.next) != null);

}

}

return null;

}

5 扩容操作

---

谈数组扩容之前，我们先带着一个疑问：为什么数组大小必须是2^n?

我们知道扩容分两步：

最后

我想问下大家当初选择做程序员的初衷是什么？有思考过这个问题吗？高薪？热爱？

既然入了这行就应该知道，这个行业是靠本事吃饭的，你想要拿高薪没有问题，请好好磨练自己的技术，不要抱怨。有的人通过培训可以让自己成长，有些人可以通过自律强大的自学能力成长，如果你两者都不占，还怎么拿高薪？

架构师是很多程序员的职业目标，一个好的架构师是不愁所谓的35岁高龄门槛的，到了那个时候，照样大把的企业挖他。为什么很多人想进阿里巴巴，无非不是福利待遇好以及优质的人脉资源，这对个人职业发展是有非常大帮助的。

如果你也想成为一名好的架构师，那或许这份Java核心架构笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。

中高级开发必知必会：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
很多人想进阿里巴巴，无非不是福利待遇好以及优质的人脉资源，这对个人职业发展是有非常大帮助的。

如果你也想成为一名好的架构师，那或许这份Java核心架构笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。

中高级开发必知必会：

[外链图片转存中…(img-osSperS9-1713418691984)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-On8rAuNt-1713418691984)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！