后端面试每日一题 聊聊HashMap

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;

}

}

可以看出每个哈希桶中包含了四个字段：hash、key、value、next，其中 next 表示链表的下一个节点。

JDK 1.8 之所以添加红黑树是因为一旦链表过长，会严重影响 HashMap 的性能，而红黑树具有快速增删改查的特点，这样就可以有效的解决链表过长时操作比较慢的问题。

核心属性

---

HashMap 源码中包含了以下几个属性：

// HashMap 初始化长度

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

// HashMap 最大长度

static final int MAXIMUM_CAPACITY = 1 << 30; // 1073741824

// 默认的加载因子 (扩容因子)

static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 当链表长度大于此值且容量大于 64 时

static final int TREEIFY_THRESHOLD = 8;

// 转换链表的临界值，当元素小于此值时，会将红黑树结构转换成链表结构

static final int UNTREEIFY_THRESHOLD = 6;

// 最小树容量

static final int MIN_TREEIFY_CAPACITY =

常见问题

---

JDK 1.8 HashMap 扩容时做了哪些优化？

• HashMap采用链地址法，低十六位和高十六位异或以及hashlength-1来减少hash冲突

• 在1.7采用头插入，1.8优化为尾插入，因为头插入容易产生环形链表死循环问题

• 在1.7扩容位置为hash 原容量判断，为0放低位，否则高位，低位位置不变，高位位置=原位置+原容量

• 树化和退树化8和6的选择，红黑树平均查找为logn，长度为8时，查找长度为3，而链表平均为8除以2；当为6时，查找长度一样，而树化需要时间；然后中间就一个数防止频繁转换

• 容量设置为2的n次方主要是可以用位运算实现取模运算，位运算采用内存操作，且能解决负数问题；同时hashlength-1时，length-1为奇数的二进制都为1，index的结果就等同与hashcode后几位，只要hashcode均匀，那么hash碰撞就少

• 负载因子.主要是太大容易造成hash冲突，太小浪费空间

加载因子为什么是 0.75？

加载因子也叫扩容因子或负载因子，用来判断什么时候进行扩容的，假如加载因子是 0.5，HashMap 的初始化容量是 16，那么当 HashMap 中有 16*0.5=8 个元素时，HashMap 就会进行扩容。

那加载因子为什么是 0.75 而不是 0.5 或者 1.0 呢？

这其实是出于容量和性能之间平衡的结果：

• 当加载因子设置比较大的时候，扩容的门槛就被提高了，扩容发生的频率比较低，占用的空间会比较小，但此时发生 Hash 冲突的几率就会提升，因此需要更复杂的数据结构来存储元素，这样对元素的操作时间就会增加，运行效率也会因此降低；

• 而当加载因子值比较小的时候，扩容的门槛会比较低，因此会占用更多的空间，此时元素的存储就比较稀疏，发生哈希冲突的可能性就比较小，因此操作性能会比较高。

还有一点是因为，为了提升扩容效率，HashMap的容量（capacity）有一个固定的要求，那就是一定是2的幂。所以，如果负载因子是3/4的话，那么和capacity的乘积结果就可以是一个整数

所以综合了以上情况就取了一个 0.5 到 1.0 的平均数 0.75 作为加载因子。

HashMap 源码中三个重要方法：查询、新增和数据扩容。

先来看查询源码：

public V get(Object key) {

Node<K,V> e;

// 对 key 进行哈希操作

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;

// 非空判断

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

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

// 判断第一个元素是否是要查询的元素

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

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

return first;

// 下一个节点非空判断

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

// 如果第一节点是树结构，则使用 getTreeNode 直接获取相应的数据

if (first instanceof TreeNode)

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

do { // 非树结构，循环节点判断

// hash 相等并且 key 相同，则返回此节点

if (e.hash == hash &&

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

return e;

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

}

}

return null;

}

从以上源码可以看出，当哈希冲突时我们需要通过判断 key 值是否相等，才能确认此元素是不是我们想要的元素。

HashMap 第二个重要方法：新增方法，源码如下：

public V put(K key, V value) {

// 对 key 进行哈希操作

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;

// 哈希表为空则创建表

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

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

// 根据 key 的哈希值计算出要插入的数组索引 i

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

// 如果 table[i] 等于 null，则直接插入

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

else {

Node<K,V> e; K k;

// 如果 key 已经存在了，直接覆盖 value

if (p.hash == hash &&

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

e = p;

// 如果 key 不存在，判断是否为红黑树

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;

}

// key 已经存在直接覆盖 value

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;

}

新增方法的执行流程，如下图所示：

HashMap 第三个重要的方法是扩容方法，源码如下：

final Node<K,V>[] resize() {

// 扩容前的数组

Node<K,V>[] oldTab = table;

// 扩容前的数组的大小和阈值

int oldCap = (oldTab == null) ? 0 : oldTab.length;

int oldThr = threshold;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

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

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

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

大类就是：

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

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
(img-st85tHNa-1712412240563)]

[外链图片转存中…(img-iGgVluVg-1712412240564)]

[外链图片转存中…(img-x1z6l4st-1712412240564)]

[外链图片转存中…(img-KWDNgnM3-1712412240564)]

[外链图片转存中…(img-a8ZPerBM-1712412240564)]

[外链图片转存中…(img-sPqpRKbL-1712412240564)]

[外链图片转存中…(img-yaPoBvPw-1712412240565)]

[外链图片转存中…(img-bfFQ1QRt-1712412240565)]
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！