Java面试高频考点：HashMap核心机制

问：为什么哈希 / 扰动函数能降低 hash 碰撞？

答：

1. 对原始哈希值做二次变换，打散高位特征
2. 让高位参与索引计算，避免高位不同低位相同
3. 使哈希值分布更均匀，减少哈希碰撞概率
4. 充分利用 32 位哈希值的所有位信息

记忆口诀：扰动打散高位，减少哈希碰撞

问：HashMap 的扰动函数是怎么实现的？

答：

1. 实现为 h = key.hashCode () ^ (h>>> 16)
2. 将哈希值右移 16 位，与原哈希值异或
3. 让高位特征融入低位，提升分布均匀性
4. 是轻量级的二次哈希，性能开销极低

记忆口诀：右移 16 位，高低位异或

问：HashMap 为什么用 & 运算代替 % 取模？

答：

1. 数组长度为 2 的幂次时，(n-1)&hash 等价于 hash% n
2. 位运算 & 的执行效率远高于取模运算 %
3. 大幅提升哈希索引的计算性能
4. 配合扰动函数，保证索引分布均匀

记忆口诀：& 比 % 快，2 的幂次等价

问：HashMap 的 get 实现是怎样的？

答：

1. 计算 key 的哈希值，通过 hash&(length-1) 定位桶
2. 检查桶首节点，匹配则直接返回对应 value
3. 首节点是 TreeNode 则用红黑树查找，否则遍历链表
4. 找到匹配 key 返回 value，未找到返回 null

记忆口诀：哈希定位，先查首，树链分查

问：HashMap 的 get 方法时间复杂度是多少？

答：

1. 无哈希冲突时，时间复杂度为 O (1)
2. 存在链表时，最坏时间复杂度为 O (n)
3. 转为红黑树后，最坏时间复杂度为 O (log n)
4. 平均时间复杂度为 O (1)，性能极高

记忆口诀：平均 O (1)，最坏 O (log n)

问：HashMap 查找时为什么先比较哈希再比较 equals？

答：

1. 哈希值比较是数值比较，执行速度极快
2. 哈希不同则 key 一定不同，可快速排除不匹配
3. 哈希相同才需要调用 equals 做精确比较
4. 大幅减少 equals 调用次数，提升查找性能

记忆口诀：先比哈希快排错，再比 equals 精确匹配

问：解决哈希冲突有哪些方法呢？

答：

1. 链地址法：冲突元素存入同一桶的链表 / 红黑树
2. 线性探测：冲突时顺序查找下一个空槽位
3. 双重哈希：用两个哈希函数计算下一个位置
4. 公共溢出区：冲突元素统一存入公共溢出区

记忆口诀：链探双溢，解决冲突

问：HashMap 采用哪种方法解决哈希冲突？

答：

1. 采用链地址法作为核心冲突解决方法
2. 冲突元素先以链表存储在对应桶中
3. 链表长度超 8 且数组≥64，转为红黑树
4. 红黑树节点数 < 6，退化为链表

记忆口诀：HashMap 用链地址，链树互转

问：链地址法和线性探测的核心区别是什么？

答：

1. 链地址法冲突元素存链表，线性探测存数组
2. 链地址法无聚集问题，线性探测易产生聚集
3. 链地址法适合频繁增删，线性探测适合查询
4. 链地址法需额外指针空间，线性探测不用

记忆口诀：链法无聚集，探测易聚集

问：HashMap 是线程安全的吗？多线程下会有什么问题？

答：

1. HashMap 不是线程安全的，是非同步数据结构
2. JDK7 扩容头插法可能导致环形链表死循环
3. 多线程同时 put 可能导致元素覆盖丢失
4. 扩容时并发 get 可能返回 null

记忆口诀：HashMap 非线程安全，死循环丢数据

问：怎么保证 HashMap 的线程安全？

答：

1. 使用 ConcurrentHashMap 替代，高并发首选
2. 使用 Collections.synchronizedMap 包装
3. 手动加 synchronized 锁或其他同步机制
4. 使用 ThreadLocal 维护线程私有实例

记忆口诀：替代、包装、加锁、线程私有

问：JDK8 的 HashMap 解决了什么线程安全问题？

答：

1. 扩容改用尾插法，解决环形链表死循环
2. 但仍存在元素覆盖、get 返回 null 问题
3. 本质仍非线程安全，多线程需用并发集合
4. 红黑树优化提升冲突时的查询性能

记忆口诀：JDK8 改尾插，解决死循环问题

问：Java 泛型中的通配符 T、E、K、V、？分别是什么含义？

答：

1. T：表示任意具体 Java 类型，用于泛型类 / 方法定义
2. E：表示集合中的元素类型，如 List<E>
3. K：表示键值对中的键类型，V 表示值类型
4. ？：表示不确定的任意类型，用于方法参数

记忆口诀：T 类 E 元 K 键 V 值？通配

问：泛型通配符 T 和？的核心区别是什么？

答：

1. T 用于定义泛型类 / 方法，是确定的类型
2. ？用于方法参数 / 返回值，是不确定的类型
3. T 可进行类型操作，？不能直接操作类型
4. T 需指定具体类型，？可代表任意类型

记忆口诀：T 定义用，？传参用

问：什么是上界通配符和下界通配符？

答：

1. 上界通配符？extends E：表示 E 或其子类
2. 下界通配符？super E：表示 E 或其父类
3. 上界用于读取，下界用于写入
4. 配合 PECS 原则，提升泛型代码灵活性

记忆口诀：上界 extends，下界 super，读上写下

问：为什么 ArrayList 线程不安全却在开发中被广泛使用？

答：

1. 绝大多数场景 List 是线程私有，无并发问题
2. 无锁开销，所有操作性能远高于线程安全集合
3. 设计哲学：不强制为不需要的功能买单
4. 提供快速失败机制，便于发现并发问题

记忆口诀：单线程用 ArrayList，性能高无开销

问：多线程环境下如何正确使用 List？

答：

1. 使用 Collections.synchronizedList 包装 ArrayList
2. 使用 CopyOnWriteArrayList，适合读多写少
3. 不推荐使用 Vector，性能差已被淘汰
4. 复合操作如迭代仍需手动加锁保证安全

记忆口诀：多线程用并发 List，读多写少用 COW

问：Vector 为什么被淘汰了？

答：

1. 所有方法加 synchronized，性能开销大
2. 复合操作如迭代仍非线程安全，需手动加锁
3. 被 Collections.synchronizedList 和 COW 替代
4. 设计老旧，不符合现代集合框架理念

记忆口诀：Vector 性能差，已被并发集合替代

问：Java 中 List 的常用高效操作有哪些？

答：

1. 去重：stream.distinct () 一行代码实现
2. 删除元素：removeIf () 按条件批量删除
3. 排序：Collections.sort () 或 lambda 表达式排序
4. 集合运算：stream 实现交并差集和去重并集

记忆口诀：List 常用操作，流一行搞定

问：List 去重的正确方法有哪些？

答：

1. Java8+：stream.distinct () 保留插入顺序
2. 利用 HashSet 去重，性能高但无序
3. 双重 for 循环 + contains，性能差不推荐
4. 一行代码即可完成，简洁高效

记忆口诀：流去重保序，HashSet 去重快

问：List 删除元素为什么不能用正序 for？

答：

1. 正序删除会导致元素前移，出现漏删
2. 推荐使用 removeIf ()，一行代码安全删除
3. 倒序 for 循环删除，不会出现索引错位
4. 使用 Iterator 迭代器删除，避免并发异常

记忆口诀：正序删漏删，倒序迭代最安全