Java基础面试题全解析：数据类型、集合、并发与JVM避坑指南

1. Java语言基础陷阱：那些挂在嘴边的知识点，其实最容易翻车

做Java面试辅导这几年，我反复跟候选人强调一个观点：Java基础面试题看似简单，其实是最容易拉开差距的地方。你以为背了几个经典题就能过关，结果面试官稍微追问一句“为什么”，就露馅了。这个“Java基础知识面试题大集合”系列，就是想把那些高频考点掰开了揉碎了讲清楚。

先说一个真实场景：某次模拟面试，候选人流畅地背出了“String是不可变的”，我问了一句“那String str = new String("abc")创建了几个对象”，他当场卡住。你看，面试官要的不是结论，而是推导过程。本文会把Java基础涉及的数据类型、面向对象、集合框架、并发编程、JVM内存、异常处理这几个核心模块逐一拆解，每一道题都附上我实际辅导中遇到的追问思路和避坑经验，适合准备校招、社招或者单纯想夯实基础的开发者参考。

1.1 基本数据类型与包装类型的“隐藏关卡”

基础面试题第一关，几乎都是问基本数据类型。八个基本类型：byte、short、int、long、float、double、char、boolean，这个谁都能背出来。但面试官真正想考察的是底层存储逻辑。比如int的取值范围为什么是-2^31到2^31-1？因为int用32位存储，最高位是符号位，剩下31位表示数值，所以最大值是2^31 - 1，最小值是-2^31。float和double的精度问题也是重灾区，我见过无数候选人用float存金额导致线上事故，这类问题在面试中一定要主动讲出来，反而能加分。

包装类型的缓存机制是真正的隐藏考点。Integer缓存区间是-128到127，这个数字怎么来的？JVM规范里规定了一个低端缓存范围，默认就是-128到127，通过系统参数可以调大上限。你想想，为什么偏偏是这个范围？因为绝大多数业务场景里的小整数都在这个区间，缓存它能显著减少对象创建。面试题常考的是：

Integer a = 100; Integer b = 100; System.out.println(a == b); // true Integer c = 200; Integer d = 200; System.out.println(c == d); // false

很多人背了结论，却说不清原理。实际上Integer a = 100走的是Integer.valueOf(100)，方法内部先查缓存表，命中就返回缓存对象，所以a和b指向同一个对象。而200超出缓存范围，每次都会new一个新对象，所以c和d指向不同对象。我建议你在回答时主动补一句“如果用了new Integer(100)，那即使值相同也是不同对象”，这样既展示深度又显得严谨。

1.2 String的不可变性与常量池

String问题绝对是Java基础面试题大集合里的“C位”。不可变性是什么意思？String内部是用private final char[]（JDK8及以前）或byte[]（JDK9开始）存数据的，加上final修饰，一旦赋值就不能改指向，内部数组也没有对外暴露修改方法。这个设计有几个关键价值：

• 字符串常量池可以安心复用对象，不用担心一个引用改了值影响其他引用
• 做HashMap的key很安全，哈希值不会因为内容变化而失效
• 多线程环境下天然线程安全

我经常让候选人写代码演示，很多人写出String s = "a" + "b"，然后问这句发生了什么。实际上编译器在编译期就能确定结果，直接优化成String s = "ab"。但如果写成String s2 = s1 + "b"，编译期无法确定，运行时会生成StringBuilder做拼接，再调用toString。

再聊常量池，String s = "abc"和String s = new String("abc")的区别。前者先在常量池找，没找到就创建，返回池中对象引用；后者直接在堆内存new一个对象，中间还可能触发常量池创建一次。所以new String("abc")最多创建两个对象，最少一个。为什么是“最多两个”？因为常量池里可能已经有“abc”了，那就只new一个堆对象。

1.3 == 与 equals 的底层逻辑

这道题属于“送分题”还是“送命题”，取决于你有没有想清楚。==比较的是栈中的值，基本类型比的是数值，引用类型比的是引用地址。equals是个方法，Object类里默认就是用==实现，但子类可以重写。

面试官经常问“重写equals必须重写hashCode吗”，答案是必须，而且有明确约束：两个对象equals相等，hashCode必须相等。原因很简单，在HashMap这类散列结构里，哈希值不同会分配到不同桶，导致明明相等的对象在集合里出现两个拷贝。反过来，hashCode相同不代表equals相等，因为哈希碰撞是正常物理现象。

我踩过一个实际坑：某公司有个实体类只重写了equals，没重写hashCode，结果用HashSet去重时，相同业务数据的对象被认为是不同的，线上数据直接重复。这就是基础知识不牢引发的生产事故。回答这类问题时，建议顺手把“为什么HashMap要先比hashCode再比equals”完整说一遍，面试官基本都会另眼相看。

2. 面向对象三剑客：封装、继承、多态的面试官视角

面向对象是整个Java的基石，面试题再怎么变，核心还是围绕这三点转。很多候选人把“继承是多态的基石”挂在嘴边，但问具体场景就答不上来。这一章我从面试官常问的三个角度拆解。

2.1 重载与重写的区别，以及协变返回类型

重载是同一个类里方法名相同、参数列表不同，编译期就确定了调用哪个版本，这叫静态分派。重写是子类重新实现父类方法，方法签名和返回类型要么相同要么是协变返回类型，运行时根据实际对象类型动态绑定，这叫动态分派。

面试中有一个进阶考法：多态到底多态在哪里？答案是只有方法调用是多态的，字段访问不具备多态性。看这个例子：

class Parent { String name = "parent"; void hello() { System.out.println("parent hello"); } } class Child extends Parent { String name = "child"; @Override void hello() { System.out.println("child hello"); } } Parent p = new Child(); p.hello(); // child hello System.out.println(p.name); // parent

方法调用走的是虚方法表，运行时找到Child类的方法；但字段访问在编译期就定好了，根据引用类型Parent来解析。很多候选人栽在这个细节上。

2.2 接口与抽象类：不只是“一个能多继承一个不能”

这道题是面试必考题，大部分人回答“接口可以多实现，抽象类只能单继承”，这只答了一半。真正的核心差异在于设计语义：

• 抽象类是“is-a”关系，表达的是同一类事物的公共属性和行为，比如“动物”抽象类，子类猫、狗都是动物
• 接口是“has-a”能力契约，表达的是“具备某种能力”，比如Comparable表达“可比较”

JDK8之后接口也能有default方法和static方法，那两者边界更模糊了。我自己的经验法则是：能用接口描述能力就优先用接口，需要复用基类状态和构造逻辑时才用抽象类。面试时能说出“接口是行为协议，抽象类是模板骨架”这种层面，基本就过关了。

2.3 构造器与初始化顺序：一道经典“大魔王”题

我每次辅导都必考这道题：有父类静态块、子类静态块、父类实例块、子类实例块、父类构造器、子类构造器，new一个子类对象，执行顺序是什么？

正确顺序是：

1. 父类静态代码块
2. 子类静态代码块
3. 父类实例代码块
4. 父类构造器
5. 子类实例代码块
6. 子类构造器

要记住两个原则：静态先行且只执行一次、先父后子。实例代码块其实是在构造器之前由编译器插入的，相当于构造器的前置扩展。面试追问一般会问你“如果静态变量被引用但没有new对象，会不会触发实例代码块”，答案是不会，静态代码只和类加载有关。这类题考察的是你对JVM类加载和对象实例化生命周期的理解程度。

3. 集合框架高频考点：别只知道ArrayList和HashMap

集合框架是Java基础面试题大集合里分量最重的部分。几乎每一轮技术面试都会问集合，而从你回答的深度，面试官能判断你是背题还是真懂。这一章挑四个最常考的容器细节讲透。

3.1 ArrayList扩容机制：为什么默认容量是10

ArrayList底层是Object数组，默认初始容量是10。这个10怎么来的？看源码，DEFAULTCAPACITY_EMPTY_ELEMENTDATA是空数组，第一次add时通过grow方法计算扩容。扩容公式是oldCapacity + (oldCapacity >> 1)，也就是1.5倍。

追问点通常有两个：一是为什么是1.5倍而不是2倍？因为扩容需要Arrays.copyOf把老数组元素复制到新数组，这是O(n)操作，太大浪费内存，太小频繁拷贝，1.5倍是空间和时间的一个折中。二是为什么默认不直接创建容量10的数组？因为懒加载策略，空数组不占实际内存，等你真正要add时才分配，这是节约内存的优化。

还有个小细节，ensureCapacity方法可以手动提前扩容，如果你事先知道要存很多元素，先调一下能避免多次扩容开销。我实际测试过，预分配容量能提升插入性能5%-10%，大数据量下会更明显。

3.2 HashMap的put流程、扩容与红黑树阈值

HashMap是面试重灾区，几乎每个面试官都会深挖。我先说整体骨架：底层是Node数组加链表，当链表长度超过阈值8且总容量不小于64时，链表转红黑树。

put流程可以这样表述：

1. 对key做hash运算，(h = key.hashCode()) ^ (h >>> 16)，高16位和低16位异或，让哈希值分布更均匀
2. 计算桶下标：(n - 1) & hash，因为n是2的幂，减一后做与运算和取模效果一样但效率更高
3. 如果桶为空直接放新节点
4. 如果桶不为空，遍历链表找key，找到就替换value
5. 链表长度达到8且容量大于等于64就转红黑树
6. 最后检查size是否超过threshold，超过就resize

为什么树化阈值选8？源码注释里有解释，泊松分布下链表长度达到8的概率已经极低，约千万分之一，这个值是为了抵御极端哈希碰撞攻击。

扩容就更绕了，旧数组长度16，扩容后32，有个巧妙设计：节点在新桶里的索引要么不变，要么是“旧索引+旧容量”。因为(n - 1) & hash里，n从16变成32，多出来的那一位正好决定key落在哪个位置。源码里用e.hash & oldCap来判断，结果0留在原位置，非0去“原位置+oldCap”。我建议你亲手画一下16到32的扩容流程图，这个理解透了HashMap就基本拿下了。

3.3 ArrayList与LinkedList：谁适合随机访问，谁适合增删

经典送分题，但我要提醒你，真相和很多人说的不一样。ArrayList基于数组，随机访问O(1)，尾部追加O(1)均摊；LinkedList基于双向链表，随机访问O(n)，头尾增删O(1)。问题在于，中间插入谁更快？如果ArrayList插入位置在中间，要做System.arraycopy移动元素，复杂度O(n)；LinkedList插入要遍历到目标节点，复杂度也是O(n)，但常数项更小。

我在一次性能测试中实测过：10万元素LinkedList在头部插入，耗时约1ms；ArrayList在头部插入，耗时超过400ms，因为每次都要整体后移。但如果是“遍历的同时删除”，LinkedList用迭代器删除是O(1)，ArrayList每删一次就搬一次家，性能天差地别。所以面试时别背结论，要说场景，这样才有区分度。

3.4 ConcurrentHashMap的锁粒度演进与面试新趋势

JDK7的ConcurrentHashMap是Segment分段锁，默认16个Segment，锁粒度是Segment级别的；JDK8改成了CAS加synchronized锁住桶头节点，锁粒度细到单个桶。这个演进非常能体现并发编程设计思想。

JDK8的put流程是：

• 若桶为空，用CAS插入，无竞争直接成功
• 若桶非空，synchronized锁住第一个节点，再做插入
• 若节点是ForwardingNode，说明正在扩容，当前线程帮忙一起扩容

面试官如果追问“为什么JDK8放弃Segment”，你可以说：Segment继承ReentrantLock，一个Segment管多个桶，锁竞争多；而且每次put都要两次哈希定位Segment再定位桶。JDK8直接锁桶头，竞争概率大大降低，并且CAS无锁操作更快。我还建议你提一下size()方法，JDK8虽然没有全局锁，但用了baseCount加CounterCell数组，并发累加时各个线程往自己的Cell里加，最后再汇总，很精妙。

4. 多线程与并发：基础题里的进阶分水岭

多线程是Java基础面试题大集合里最容易“两极分化”的模块。水平一般的人只能背出线程创建四种方式，水平高的人能从线程状态聊到锁升级。这一章照顾不同层次，从基础到进阶一次说透。

4.1 线程创建的四种方式，哪种最优

Thread、Runnable、Callable+Futrue、线程池，这是标准答案。Runnable是函数式接口，只有一个run()方法，无返回值，无法抛受检异常。Callable有返回值，可以抛异常，配合FutureTask可以拿到异步结果。线程池最推荐，能把线程复用和管理交给框架。网上大量教程喜欢说“实现Runnable比继承Thread好”，因为Java单继承，实现接口灵活，同时解耦任务和执行逻辑。

但我会补一个实际经验：现在的工程代码里，直接用原始Thread的场景已经非常少了，几乎都是ExecutorService加CompletableFuture。如果你面试时能主动把话题引到CompletableFuture的异步编排上，说明你确实用过，不是只看过面经。

4.2 线程六种状态与转换路径

Thread.State枚举定义了六个：NEW、RUNNABLE（包含可运行和运行中）、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。注意没有单独的RUNNING状态，JVM把ready和running统一归为RUNNABLE。

状态转换是高频追问点：

• Thread.start()：NEW -> RUNNABLE
• synchronized锁未获得：RUNNABLE -> BLOCKED
• object.wait()：RUNNABLE -> WAITING，需要notify/notifyAll唤醒
• Thread.sleep(1000)：RUNNABLE -> TIMED_WAITING，时间到自动恢复
• join(1000)：TIMED_WAITING，最多等1秒

一个常见错误是搞混sleep和wait。我强调一下：sleep是Thread的静态方法，不释放锁；wait是Object的方法，释放锁。为什么wait定义在Object里？因为wait是让“持锁的对象”进入等待，任何对象的监视器都能被wait，不是线程特有的行为。

4.3 synchronized锁升级与偏向锁的“小秘密”

JDK6之前synchronized是重量级锁，JDK6之后做了大量优化，锁可以升级依次是：无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁。偏向锁的核心想法是：大多数情况下锁不仅不竞争，而且总是同一个线程获取，那就让这个线程获得锁时做个标记，后续重入就不再走CAS了。

轻量级锁则用CAS尝试在对象头中替换锁记录，如果失败且有竞争，就膨胀成重量级锁。面试官爱问“为什么锁可以升级但不可以降级”？因为降级需要检查持有情况，逻辑复杂，JVM权衡后不支持，只在偏向锁被批量撤销时有特殊情况。

我自己的体会是，这道题考的不是结论，而是你对“锁状态在对象头里怎么存储”的认知。对象头里有一块Mark Word，存hashCode、分代年龄、锁状态标志位。锁状态不同，Mark Word的位模式就不同。能画出这个表的人，面试官基本不会再刁难。

4.4 volatile能保证什么，不能保证什么

volatile有两个语义：可见性和有序性，但不保证原子性。可见性是因为volatile变量在写完后会强制刷新到主内存，读时会从主内存重新加载。有序性是因为编译器和CPU不能对volatile读写做重排序，JMM用内存屏障实现这个约束。

经典的i++问题：i++不是原子操作，分读、加、写三步。即使volatile保证可见性，两个线程同时读到值100，各自加1再写回，最后是101而不是102。要保证原子性就得上AtomicInteger的CAS或者synchronized。

面试进阶问题：单例DCL为什么volatile不能省？因为instance = new Singleton()不是原子操作，汇编级别分三步：分配内存、初始化对象、把引用指向内存。如果不加volatile，步骤2和3可能重排序，另一个线程拿到未初始化完成的对象引用，直接使用就出事。volatile禁止这个重排序，保证“引用可见时对象一定初始化完了”。

5. JVM底层机制：基础题里含金量最高的部分

聊到JVM，很多Java基础薄弱的候选人直接露怯。但我认为，面试初级岗时，JVM考的是“知道得准确”，不要求“源码级别精通”。这一章把运行时数据区、垃圾回收、类加载三个核心讲透。

5.1 运行时数据区：堆、栈、方法区的黄金三角

JVM把内存划分为几个区域，按线程是否共享分两类。线程共享：堆、方法区、运行时常量池；线程私有：虚拟机栈、本地方法栈、程序计数器。

面试高频题“堆和栈的区别”，我会用生活类比来回答。栈像函数调用的草稿纸，一个方法调用就在栈帧里记好局部变量、操作数栈、返回地址，方法结束帧就销毁，所以栈内存的分配和回收都很快。堆像仓库，对象都放里面，谁需要谁引用，回收依赖GC。栈存基本类型值、对象引用；堆存真实对象数据。

JDK8以后方法区用元空间实现，和永久代最大的区别是：元空间不在虚拟机内存里，而是使用本地内存。为什么换？因为永久代默认比较小，字符串常量池容易OOM，而元空间用本机内存，默认几乎没上限，由系统内存决定。另一个变化是字符串常量池JDK7就挪到堆里了，很多人不知道这个细节。

5.2 垃圾回收算法与GC Roots，面试必答的排查逻辑

垃圾回收的核心第一步是判断哪些对象可以回收。引用计数法简单但有循环引用问题，JVM用可达性分析：从GC Roots出发，能到达的对象就是活的，到不了的就是垃圾。

GC Roots有哪些？主要有：

• 虚拟机栈中局部变量引用的对象
• 方法区中类静态属性引用的对象
• 常量引用的对象
• 本地方法栈JNI引用的对象
• 活跃线程的引用

引用类型也常考，强引用、软引用、弱引用、虚引用。软引用在内存不足时被回收，适合做缓存；弱引用下次GC一定被回收，ThreadLocal的ThreadLocalMap就用了弱引用key，这就是ThreadLocal内存泄漏讨论的根源。

回收算法里，标记-清除有碎片化问题，标记-复制浪费空间，标记-整理需要移动对象。新生代用标记-复制，老年代用标记-整理或标记-清除。为什么新生代用复制？因为绝大部分对象朝生夕灭，存活下来的很少，复制成本低。

G1收集器则把堆分成一个个Region，每个Region既可以当新生代也可以当老年代，通过维护一个优先级列表，优先回收垃圾最多的Region，实现了可预测的停顿时间。面试时能把G1“回收价值优先”的调度思路说出来，已经是加分项了。

5.3 类加载过程与双亲委派，一道能测出深度的题

类加载分五个阶段：加载、验证、准备、解析、初始化。加载就是找到.class文件并读入内存；验证是校验字节码合法性；准备是给静态变量分配内存并赋默认值；解析是把符号引用替换为直接引用；初始化才真正执行静态代码块和静态变量赋值。

双亲委派模型是重点。类加载器分三层：启动类加载器（Bootstrap）、扩展类加载器（Platform，JDK8叫Extension）、应用类加载器（App）。当一个类需要加载时，先委托给父加载器，父加载器能加载就父加载器说了算，爸爸们都不行才轮到子加载器。

为什么这样设计？安全。比如你自己写一个java.lang.String，如果不用双亲委派，类加载器可能就加载你的String了，这会破坏核心API。双亲委派保证最核心的类库始终由启动类加载器加载，防止核心类被篡改。Tomcat打破双亲委派是因为它要隔离多个Web应用的类，但又不想影响容器自己的类加载，这就是另一个层面的定制方案了。

6. 异常处理与代码健壮性：面试答得好，写码更要练

异常部分是Java基础面试题大集合里最“实用主义”的环节，因为每家公司都吃过线上异常处理不当的亏。这里不需要你背太多概念，但要能讲清楚设计思想和实际权衡。

6.1 受检异常与非受检异常的设计哲学

Java把异常分为两大类。受检异常（checked exception）在编译期强制处理，要么throws要么try-catch，典型代表IOException、SQLException。非受检异常（runtime exception）运行时才抛出，编译期不强制，典型代表NullPointerException、IndexOutOfBoundsException。

面试官爱问“受检异常是不是设计失败”。这个没有标准答案，但你可以分两面讲：受检异常强制程序员考虑失败路径，但过度使用会让代码塞满try-catch，业务逻辑被异常处理淹没。所以现代实践里，很多框架如Spring倾向于把内部异常都包装成非受检异常，再由AOP统一处理。你会发现，现在写代码时“受检异常”的比例在降低，这就是工程演进的趋势。

6.2 finally块与try-with-resources，你选哪个

finally块保证try正常结束或异常中断后都会执行，经典用途是关闭资源。但如果关闭资源本身又抛异常，就麻烦了。比如：

try { inputStream.read(); } finally { inputStream.close(); // 如果这里抛异常，会覆盖try里的原始异常 }

这个问题在JDK7引入了try-with-resources后得到优雅解决：

try (InputStream in = new FileInputStream("file.txt")) { // 使用资源 }

这背后依赖AutoCloseable接口，close方法会被自动调用，而且如果try块和close都抛异常，原始异常会被保留，close的异常作为抑制异常添加进去。我实际排查过一个案例，就是close异常把业务异常吞了，日志里只有无关的IO异常，问题定位花了两天。用try-with-resources后，这种坑从机制上就消失了。

6.3 异常处理的三个实用心得

第一个心得是别捕获Exception后打印日志就完事。要区分可恢复和不可恢复：像“参数校验失败”你可返回错误码；像“数据库连不上”你捕获了也恢复不了，应该尽快fail-fast，让上层感知。

第二个心得是异常信息要带上下文。常见低质量写法是throw new RuntimeException("错误")，我改法通常是throw new BusinessException(ErrorCode.X_NOT_FOUND, "用户id=" + userId + " 不存在")，把关键参数放进去，线上日志一眼就能定位。

第三个心得是慎用e.printStackTrace()。这是最容易被吐槽的，printStackTrace是同步写控制台，高并发下是性能杀手，还容易把日志打乱。统一用日志框架包装，比如log.error("操作失败", e)，把堆栈完整输出到日志系统里。

7. 备考策略与高频追问演练：一条可复制的刷题路径

前面六章把知识模块过了一遍，这一章聊聊“怎么准备”这件事。毕竟Java基础知识面试题大集合再大，不能只背题，要有一套自己的方法论。

7.1 从“背答案”到“讲推导”的转变技巧

我辅导过很多候选人，发现一个通用问题：大家能背出正确答案，但经不起连续追问。比如能说出“HashMap是非线程安全的”，但问“ConcurrentHashMap为什么线程安全”就卡壳；知道“ArrayList扩容是1.5倍”，但问“16扩容到24还是32”就犹豫了。

我建议的转变方法是三层递进法：

• 第一层：记忆结论，比如“HashMap默认容量16”
• 第二层：追溯源码，找到这个结论在哪个类哪个方法里定义
• 第三层：思考设计意图，为什么是16而不是10或20

为什么不选奇数或者质数？因为HashMap要求容量是2的倍数，配合位运算才能高效算出桶下标。这样你回答问题时就不再是“背”，而是“推导”。面试官怎么追问你都能接住。

7.2 技术面之外的加分项：主动沟通与结构化表达

面试不是考试，是交流。我见过技术能力不错、但表达混乱的候选人，明明会做却说不出逻辑，非常吃亏。建议用总-分-总结构回答问题：先一句话给结论，再拆成两三个要点展开，最后概括影响或应用。比如回答“synchronized原理”，先说“它通过Monitor对象实现互斥”，再展开锁升级路径，最后说“在低竞争场景下性能也可以很好，不必无脑用Lock”。

另外，遇到不会的问题不要直接说“不知道”。你可以说“这个点我没深入研究过，但我推测可能是……”或者“我了解的是……，如果有不对的地方请指正”，把不会的题拆到你知道的相邻领域去。这个技巧屡试不爽，至少能保住印象分。

7.3 我整理的高频考点速查表

这块内容是一个信息密度较高的汇总表，适合复习时快速自检。如果你能不看提示把每一项的关键点说满三分钟，那面试时基本就稳了：

考点模块	必背结论	深层追问点	常见失分原因
基本类型	int 32位，范围-2^31~2^31-1	自动拆装箱发生的场景	记错float精度表示
字符串	String不可变，常量池复用	new String创建几个对象	混淆字符串拼接优化机制
集合	HashMap容量2^n，负载因子0.75	为什么负载因子是0.75	不理解扩容触发条件
并发	synchronized可重入	锁升级过程与对象头变化	混淆volatile和原子性
JVM	GC Roots可达性分析	哪些对象可以做GC Roots	答不出线程栈引用
异常	try-with-resources自动关闭	抑制异常机制	忽略close异常覆盖主异常
反射	运行时获取类信息	反射为什么慢	只用不深究性能瓶颈

这个速查表不是让你死记硬背，而是用来检测你自己“还有哪个模块不敢开口讲”。我常说，面试不是知道得多，而是知道得准。

8. 写在最后：一些踩过坑之后才明白的道理

做Java基础辅导越久，越觉得基础题不是“八股文”。很多候选人把Java基础面试题大集合当成“题库”，背完就上考场，结果极易翻车。因为面试官早就烦透了只会背标准答案的候选人，他们要的是能聊、能推导、能落地的工程师。

我个人在实际中的体会是：拿一份高频题清单，确保每个题目都自己动手写一遍Demo，再亲手画一遍底层结构图，最后对着镜子口头讲解一遍。三个遍都过了，才算真正掌握。比如HashMap，你光看源码注释是记不住的，我建议你手写一个小Demo，打印bucket下标，观察扩容前后index变化，这样比死记“e.hash & oldCap”有效得多。

另外一个非常实用的小技巧：面试答题时可以带出**“版本演进视角”**。比如JDK7到JDK8ConcurrentHashMap的锁粒度变化、ArrayList在JDK6到JDK7之间的懒加载改动、G1在JDK9成为默认垃圾收集器。这些演进能证明你平时有关注Java生态变化，而不是面试前突击背题。

最后呢，Java基础面试题大集合永远是一张不断更新的清单，今天你掌握了HashMap的树化，明天可能面试官就问你为什么树化阈值是8而不是10。别怕，只要把“结论-源码-设计意图”三层结构养成习惯，任何追问都只是换一个切入点而已。希望这篇内容能帮你在面试桌上多一点底气，少一点慌张。