.get 的主要步骤

1. Caculate hash of supplied key.
2. Select bucket index via &hash
3. If bucket empty → 返回 null。
4. If bucket not empty:
   • The first node is checked directly.
   • If it’s a red‑black tree → 使用树查找

. 为什么 HashMap 的容量必须是 2ⁿ 的幂？

Pain point: Poor capacity selection leads to frequent rehashing and uneven distribution.

static final int tableSizeFor{
int n = cap - 1;n |= n>> 1，n |= n>> 2;n |= n>> 4，n |= n>> 8;n |= n>>16，return?1:，MAXIMUM_CAPACITY:n+1;}

• The method returns smallest power‑of‑two ≥ cap.
• A power‑of‑two length lets index calculation be a simple bit‑mask: &hash ≈ hash % n。but far faster.
• During resize from oldCap → newCap=oldCap*2,each entry eir stays at its original index or moves to index+oldCap based on a single bit check: ==0?i : i+oldCap;.

. resize 扩容机制

The default initial capacity is **16**,load factor **0.75** ⇒ threshold **12**. When #entries> threshold→resize.

.resize 主要代码摘录

final Node resize {
Node oldTab = table;其实，int oldCap =?不过，0:oldTab.length;int oldThr = threshold;int newCap,newThr=0;其实，if{ // 正常扩容
newCap=oldCap<1;//*2
       newThr=;
   }else{                         // 第一次初始化
       newCap=DEFAULT_INITIAL_CAPACITY;//16
       newThr=;//12
   }
   threshold=newThr;//更新阈值
   @SuppressWarnings
   Node newTab=new Node;table=newTab;// 将旧节点重新分配到新数组中。只检查最低位即可决定是否搬迁：
for{
... // 略去细节：遍历每条链/树，按==0?stay : move.
}
return newTab;}


⚡️ Pain point: A naive实现在resize时重新计算完整hash会导致巨大的CPU消耗；JDK通过“只检查最低位”实现 O.


. 链表何时转换为红黑树？说起来，

The conversion thresholds are defined as constants:
static final int TREEIFY_THRESHOLD = 8;按理说，// 桶中元素数≥8 时尝试树化
static final int UNTREEIFY_THRESHOLD = 6;// 树中元素数≤6 时退化回链表
static final int MIN_TREEIFY_CAPACITY = 64;// 必须先把整个 HashMap 扩容到至少64才允许树化
**Conversion logic** :
java
if


Why not treeify immediately?
- Small tables cause many collisions simply because空间太小。此时扩容往往比造树更有效。



Result: Only when桶已足够大且冲突严重时才会引入红黑树，从而将最坏情况从 O 降至 O。老实说，


. 红黑树节点 `TreeNode` 
java
static final class TreeNode
extends LinkedHashMap.Entry{
TreeNode parent;TreeNode left;TreeNode

查找时先比较 hash若相同再比较 key；若仍无法区分，则使用 tieBreakOrder 做兜底排序。怎么说呢，

. HashMap 如何处理哈希冲突？


⚠️Pain point: A bad `hashCode` implementation leads to massive冲突，查询速度从 O 降至 O。请务必保证 `equals` 与 `hashCode` 一致。



传统做法采用“拉链法”，即同一桶的所有节点通过 next 串起来。

JDK 8+ 改进当单桶长度≥8且整体容量≥64时将链表升级为红黑树，以保持查询对数级别。



场景 
时间复杂度 

理想情况 
O

仅链表冲突严重 
O

红黑树化后 
O


. Key 相等判断逻辑 

`HashMap` 判断两个键是否相等的代码片段：
java
if==key ||
))) { …老实说，}


必须同时满足的观点是。hash 相同 且。

自定义对象作为键时必须正确实现 hashCode 与 equals且满足 “相等对象的 hashCode 必须相等”。否则会出现查不到或重复存储的问题——这是面试常见陷阱之一。


. Null Key 的特殊处理 

`HashMap` 支持唯一一个 `null` 键：
java
static final int hash{return k==null?0:，}
int indexForNullKey{return &0;按理说，} // 始终指向第一个桶。即 table


所有 null 键都落在数组下标 0 中。


插入/查询过程不需要额外空指针检查，这也是很多人误以为可以随意使用多个 null 键的根源——只能有一个。


. JDK 7 与 JDK 8+ 的主要区别 

. JDK 7 


`table`: 数组 + 链表。

`put`这方面，使用"头插"导致遍历顺序倒置。

`resize`: 扩容后旧链表顺序可能翻转。引发并发环境下“环形链表”问题，从而出现死循环。.

`HashMap` 并未加入红黑树调整，在极端冲突下仍然是 O。


. JDK 8+


`table`: 数组 + 链表 + 红黑树。

再看`put`。
使用"尾插"保持插入顺序，更易于调试。

`resize`: 保持原有顺序。仅根据 `` 决定是否搬迁，实现更快且避免环形问题。

`TREEIFY_THRESHOLD`。`MIN_TREEIFY_CAPACITY` 等阈值防止盲目造树，提高空间利用率。li>
li>
li>
Pain point：：即使 JDK 8 已经大幅改进，仍然 **不是线程安全**；并发写操作仍然可能导致数据不一致或抛出 ConcurrentModificationException。推荐在多线程场景使用 {@link java.util.concurrent.ConcurrentHashMap}。





* 面试精简答案 *