Java面试八股文系统整理：基础、集合、JVM、并发全覆盖

“Java面试八股文”这几个字，我过去几年在面候选人的时候听过无数遍。有人靠它突击进大厂，也有人背了一个月却连“为什么”都答不上来。这份整理不是让你打印下来死记硬背的，而是想给你一张相对完整的复习地图：Java基础、集合、JVM、并发、Spring/MySQL/Redis、手写算法，再加上几个很容易在实际面试里翻车的编译和环境问题。如果你正在准备校招、社招，或者工作几年想系统查漏补缺，这篇内容应该比单纯刷题更有参考价值。

我先把话说在前面：没有任何一份八股文合集敢说“全网最全”，标题多少带点夸张。真正值得参考的，是它把高频考点串起来了，并且每个点都回答了“面试官为什么爱问这个”。明白这层逻辑，你背的每个答案才立得住。

1. 为什么我决定整理这份Java八股文，以及怎么用才不白背

1.1 八股文不是背出来的，是理解出来的

我在技术面试里见过太多类似场景：候选人把HashMap的底层结构背得很顺，“数组加链表，JDK8之后还会转红黑树”，但追问一句“为什么链表转红黑树的阈值是8”就卡住了。背题和理解的差距，恰恰就在这个“为什么”上。

面试官大多数时候不是要考倒你，而是想通过追问判断你是不是真的掌握。八股文只是外层答案，内层是源码、数据结构、操作系统和网络的基础知识。你背的是结论，但面试官要的是你推导结论的过程。

所以我建议这样使用这份整理：先看问题，试着用自己的话说一遍，再看答案，对照漏掉了哪些关键点。如果能把每个核心结论都讲出“因为什么，所以什么”，这场面试的容错率会高很多。

1.2 这份整理覆盖了哪些方向，复习优先级怎么排

下面这张表是我整理复习路径时的依据，不是全部知识点，但覆盖了Java岗位面试里出现频率最高的几大块。优先级是结合我自己面试别人和经验复盘排的，仅供参考。

如果你只有一到两周准备时间，优先把前四块吃透；如果时间充裕，再把框架、中间件和手写算法补齐。Java后端技术面最看重的前四块内容，也是候选人差距最容易拉开的地方。

2. Java基础面试题：从String到异常，藏在八股文底层的原理

2.1 String的不可变设计与“创建几个对象”陷阱

String是Java里被问得最频繁的类之一。它的不可变性表现在：一旦创建，字符序列不能改变。JDK8及之前，String内部是char[]；JDK9开始改成了byte[]，并且增加了一个编码标记位，因为大多数字符是拉丁字符，用一个字节存储能省不少内存。

为什么设计成不可变？三个核心好处：第一，字符串常量池可以缓存，两个引用指向同一个String对象时不用担心被改坏；第二，String的hashCode可以安全缓存，第一次计算后复用，HashMap用String做key才高效；第三，多个线程可以共享同一个String对象，天然线程安全。

经典面试题是String s = new String("abc")创建了几个对象。答案不固定：如果常量池里已经有“abc”，那么只创建一个堆对象；如果常量池里还没有“abc”，JVM会先在常量池中创建“abc”，再在堆中创建一个String对象，总共两个。如果再考intern()，你可以答：手动把字符串放入常量池，如果池中已有则返回池中对象，这样可以减少重复字符串对象。

2.2 为什么重写equals就必须重写hashCode

这个问题几乎每次面试都会出现。最直观的解释是：HashMap和HashSet这类基于哈希的集合，先通过hashCode()计算桶的位置，再通过equals()比较链表中是否存在相同元素。如果两个业务上相同的对象，hashCode()不同，它们就会被放到不同桶里，get的时候找不到，put的时候还能插入两个“逻辑重复”的key。

可以这样理解：hashCode是房间号，equals是房间里的人。别人要找张三，先通过房间号找到房间，再看看房间里的人是不是张三。如果房号对不上，连房间都进不去。

实际操作中重写equals时，也要把参与比较的字段在hashCode里用相同的规则算一遍。比如用Objects.hash(name, age)生成哈希码，保证相等的对象哈希值一定相等。IDE生成的equals和hashCode通常就是规范写法，直接使用就可以。

2.3 final、finally、finalize不要再答老一套

final修饰类表示不能被继承，修饰方法表示不能重写，修饰变量表示引用一旦赋值不能改变。这里的“不能改变”要理解准确：如果变量引用的是一个对象，对象内部字段仍然可以修改，只是引用不能指向新对象。

finally是异常处理结构中的代码块，无论try里是否抛出异常，finally都会执行，常见用途是释放资源。这里有个细节：如果finally里有return，它会覆盖try或catch中的return。实际写代码时，不要在finally里做返回操作，否则会导致异常和返回值被吞掉。

finalize完全不是同一类问题。它早期用于GC回收前的清理，但从Java 9开始被标记为废弃，因为它执行时机不确定、性能差，还可能引发对象复活问题。现在面试官问这个，更多是想听你知不知道它已经被淘汰。可替代方案是用try-with-resources和AutoCloseable，这是JDK7引入的常规资源关闭方式。

2.4 异常体系：受检异常和运行时异常怎么选

Java异常体系的根是Throwable，下面分Error和Exception。Error表示JVM层面的严重问题，比如OutOfMemoryError、StackOverflowError，应用程序一般处理不了。Exception又分受检异常和运行时异常。受检异常必须显式捕获或声明抛出，例如IOException、SQLException；运行时异常继承RuntimeException，不需要强制处理，例如NullPointerException、IllegalArgumentException。

面试里还有一个容易混淆的点：ClassNotFoundException和NoClassDefFoundError。前者是代码尝试用Class.forName或ClassLoader.loadClass加载类时，类不存在；后者是JVM在编译期类存在、运行期类定义却找不到，比如依赖没打包完整或静态初始化失败。这两个概念能分清楚，说明你对类加载机制有基本认识。

实践建议只有一句：不要用catch(Exception e) {}把异常吞掉。至少打日志并保留原始异常对象，否则线上问题查起来会非常痛苦。

3. 集合框架高频考点：HashMap、ConcurrentHashMap的源码级理解

3.1 HashMap的put流程、扩容和树化阈值

HashMap从JDK8开始是“数组 + 链表 + 红黑树”的结构。初始容量是16，默认负载因子0.75。put一个key时，流程大致是：先通过hash(key)扰动计算哈希值，让高位也参与运算，再用(n - 1) & hash定位到数组下标。如果这个位置为空，直接放进去；如果发生哈希冲突，就在链表尾部插入节点。链表长度达到8并且数组容量达到64时，链表转为红黑树；如果数组容量没到64，会先扩容。

扩容机制也是必问点。默认容量必须是2的幂，这样才能用位运算代替取模，扩容时元素要么留在原位置，要么移动到原位置加旧容量的位置，重哈希开销小。每次扩容为原来的两倍，加载因子0.75是空间和时间折中的结果。为什么树化阈值是8？因为当哈希函数分布足够均匀时，用泊松分布计算，链表长度达到8的概率非常低，设置8是作为极端冲突场景的兜底。

容易翻车的还有JDK1.7和JDK8的区别。JDK1.7用头插法，并发扩容时可能形成环形链表，导致死循环；JDK8改为尾插法，死循环问题在单链表层面有所缓解，但并发下put仍然可能丢数据。结论是：并发场景请用ConcurrentHashMap，不要自己去做额外同步。

3.2 JDK8的ConcurrentHashMap为什么放弃分段锁

JDK7的ConcurrentHashMap使用Segment分段锁，每个Segment继承ReentrantLock，把整个map分成16段，线程只锁自己操作的段。这种设计锁粒度比较粗，而且Segments数量初始化后不好扩展。

JDK8彻底改成了CAS + synchronized。插入数据时，如果对应桶为空，直接用CAS尝试放入新节点，避免加锁开销；如果桶不为空，就锁住桶里的头节点。synchronized在JDK6之后做了锁升级优化，低竞争场景下开销很小，所以这个方案比分段锁更轻量。

面试还会追问为什么size()不是精确值。因为并发情况下没法对每个桶加锁来统计，JDK8使用baseCount加CounterCell数组，size()返回的是合并后的近似值。另一个细节是mappingCount()返回long，size()返回int，数据量很大时用mappingCount()更安全。

3.3 ArrayList扩容为什么是1.5倍，LinkedList增删真的快吗

ArrayList默认初始容量是10，达到上限后扩容为原来的1.5倍，即oldCapacity + (oldCapacity >> 1)，然后调用Arrays.copyOf拷贝到新数组。为什么不直接扩容2倍？因为1.5倍相对保守，在均摊复杂度O(1)的前提下，减少内存浪费。

LinkedList基于双向链表实现。很多人背结论“LinkedList增删快，ArrayList查询快”，但这不够严谨。LinkedList如果已知要删除的节点引用，确实是O(1)；但如果只知道下标，删除前还要从头遍历定位，时间复杂度是O(n)。ArrayList随机访问是O(1)，尾部和末尾增删在均摊意义下也是O(1)，但中间插入和删除因为要移动元素，是O(n)。

实际业务里，如果不涉及频繁的中间插入删除，ArrayList通常是默认选择，因为连续内存对CPU缓存更友好。还有一个高频坑：在循环里用list.remove(i)删除多个元素，删除后下标会变化，容易漏删。正确做法是使用Iterator的remove方法，或者直接用removeIf。

4. JVM与内存问题：OOM、GC和类加载的面试深挖

4.1 运行时数据区：哪些线程私有，哪些线程共享

JVM运行时数据区是JVM面试的地基。线程私有的有三块：程序计数器、虚拟机栈、本地方法栈。线程共享的有两块：堆、方法区。JDK8之后方法区用元空间实现，字符串常量池被移到了堆中。

虚拟机栈对应每个Java方法调用，方法执行时创建栈帧，栈帧里有局部变量表、操作数栈、动态链接、方法出口。递归调用太深会抛StackOverflowError，线程请求栈深度超出虚拟机允许范围则抛OutOfMemoryError。堆是所有对象实例和数组的分配区域，也是GC的主要战场。方法区存放类元信息、运行时常量池等。

JDK8之前方法区叫永久代，JDK8换成了元空间。为什么换？因为永久代的大小难以确定，而且类元数据的回收在Full GC时容易引发性能问题。元空间使用本地内存，默认不设上限，避免永久代导致的OutOfMemoryError: PermGen space。

4.2 “Insufficient memory”类OOM的排查链路

实际开发中，java.lang.OutOfMemoryError并不少见。很多人一看到OOM就拍脑袋加-Xmx，但根源往往不是堆太小，而是存在对象无法被回收。比如静态集合持有大量对象、ThreadLocal没有清理、数据库连接池设置过大、ClassLoader泄漏导致类无法卸载。

排查OOM时，我一般按这个链路走：

1. 启动参数加上-Xms和-Xmx，并且开启GC日志，线上保留GC日志很关键。
2. 用jstat -gcutil <pid>观察GC频率，用jmap -dump:format=b,file=heap.hprof <pid>导出堆转储。
3. 使用MAT或JProfiler打开堆转储，重点看支配树里的大对象，以及org.eclipse.mat.parser等分析报告。
4. 重点排查这些位置：静态Map/List、缓存框架、未释放的IO流、线程池中的任务对象、ThreadLocal值未remove。
5. 如果是容器环境，还要注意JVM无法感知容器内存限制时，可能被cgroup OOM Killer直接杀掉，此时系统日志里会有对应记录。

一个补充点：如果你看到的是OutOfMemoryError: Insufficient memory这种信息，可能不是Java堆的问题，而是进程启动时无法从操作系统拿到足够内存，常见于物理机内存不足、容器内存限制或者同时启动太多JVM实例。处理思路是检查可用内存、减少实例数量或调整占用。

4.3 GC算法与常用收集器

垃圾回收算法有三个基础款：标记-清除、标记-复制、标记-整理。标记-清除会产生大量碎片；标记-复制适合新生代，因为对象存活率低，浪费空间不大，HotSpot把新生代分成Eden和两块Survivor，默认比例8:1:1；标记-整理适合老年代，移动对象消除碎片，但移动成本高。

分代收集把堆分成新生代和老年代。新生代对象朝生夕死，回收后存活对象晋升老年代。Minor GC触发条件是Eden区满，Full GC触发条件比较复杂，包括老年代空间不足、元空间不足、System.gc()被调用、CMS并发清理失败转Serial Old等。

面试比较常问G1和ZGC。G1把堆分成大小相同的Region，维护一个可预测的停顿时间模型，适合大堆和多核环境。ZGC使用着色指针和读屏障，暂停时间通常不超过10毫秒，适合超大堆低延迟场景。你不需要背完整源码，但至少要能说清楚“G1和CMS最大的区别是Region化、可预测停顿、以及不需要老年代和新生代物理隔离”。

4.4 类加载过程与双亲委派

类加载过程包括加载、验证、准备、解析、初始化五个阶段。加载就是根据全限定名读取字节流，生成Class对象；准备阶段为静态变量分配内存并设置零值；初始化阶段执行静态变量赋值和静态代码块。

双亲委派机制是类加载器先让父加载器尝试加载，父加载器加载不了才由自己加载。这样做的目的是防止核心类被自定义类篡改，也避免同一个类被不同加载器重复加载。Bootstrap ClassLoader加载rt.jar中的核心类，Platform/Extension ClassLoader加载扩展库，Application ClassLoader加载classpath下的类。

面试常追问“什么场景需要打破双亲委派”。最典型的例子是JDBC：DriverManager在启动类加载器加载的rt.jar里，但具体数据库驱动在classpath下，启动类加载器加载不到，所以JDBC通过ServiceLoader机制，由线程上下文类加载器加载驱动实现。另一个常见场景是Tomcat，为了支持多个Web应用之间类隔离，会破坏双亲委派。

5. 并发编程：synchronized、volatile、线程池与AQS

5.1 synchronized到底锁的什么？锁升级过程

synchronized锁的是对象，不是代码块。每个Java对象头里都有Mark Word，记录了锁状态。JDK6之后锁可以升级，基本路径是：无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁。

偏向锁的意思是，第一个获取锁的线程把锁记录在对象头里，后续再进入同步块只要检查偏向线程是不是自己，不需要做CAS。一旦发生竞争，偏向模式撤销，升级为轻量级锁。轻量级锁通过自旋等待持有锁的线程释放，自旋失败则膨胀为重量级锁，依赖操作系统的Monitor实现，涉及用户态和内核态切换，开销最大。

这里有个容易混淆的点：轻量级锁失败不一定立刻升级重量级锁，JVM会采用自适应自旋，根据历史自旋结果动态调整。另外JDK15起默认禁用了偏向锁，因为现代应用线程竞争普遍，偏向锁带来的收益已经不明显。你面试时能说出这个版本变化，会显得平时跟得比较紧。

5.2 volatile的内存语义，以及和synchronized的区别

volatile有两个核心语义：保证可见性、禁止指令重排序。它不保证原子性。JMM（Java内存模型）规定每个线程有工作内存，volatile变量的读写直接操作主内存，并且通过内存屏障防止相关指令被重排。

最经典的例子是单例模式的DCL写法。new一个对象在字节码层面有多个步骤：分配内存、初始化对象、引用指向内存。如果没有volatile，JVM可能把“引用指向内存”重排到“初始化对象”之前，另一个线程拿到引用后去访问对象，会读到半初始化状态。加volatile后禁止这种重排。

和synchronized的区别可以这样记：volatile是轻量级同步，适合一个线程写、多个线程读的状态标志；但它不能替代锁，因为复合操作如i++不是原子的。如果多个线程同时执行自增，还是要用AtomicInteger或synchronized。

5.3 线程池核心参数和执行流程

线程池构造方法有七个核心参数：核心线程数、最大线程数、空闲存活时间、时间单位、阻塞队列、线程工厂、拒绝策略。执行流程是：当线程数小于核心线程数时，创建新线程处理任务；超过核心线程数后，新任务进入阻塞队列；队列满了，再创建新线程，直到达到最大线程数；线程数达到最大值且队列也满，触发拒绝策略。

为什么用阻塞队列而不是普通队列？因为当核心线程都忙时，任务是排队等待而不是无限创建线程。阻塞队列自带线程等待和唤醒机制，适合生产者-消费者模型。

实际开发中不要直接使用Executors创建线程池。newFixedThreadPool和newSingleThreadExecutor的队列是无界的，任务堆积过多会OOM；newCachedThreadPool最大线程数是Integer.MAX_VALUE，可能创建大量线程耗尽资源。正确的做法是手动new ThreadPoolExecutor，把队列长度、线程数、拒绝策略都控制住。默认拒绝策略是AbortPolicy，直接抛RejectedExecutionException；不想让任务直接失败，可以用CallerRunsPolicy，让提交任务的线程自己执行。

5.4 AQS是什么？ReentrantLock怎么用它

AQS是AbstractQueuedSynchronizer，可以理解为JUC很多工具类的基石。核心是state状态字段加一个FIFO等待队列，再配合模板方法。子类只需要实现tryAcquire和tryRelease这类方法，AQS负责线程的排队、唤醒和中断处理。

ReentrantLock就是基于AQS实现的。它默认是非公平锁：线程在获取锁时直接尝试CAS修改state，抢不到再进队列。公平锁则先检查等待队列中是否有前驱节点，有就排队。非公平锁吞吐量通常更高，因为减少线程切换；代价是新来的线程可能插队，导致等待线程饥饿。

AQS的Condition也是高频追问点。Condition内部维护条件队列，await方法会释放锁并把线程放入条件队列，signal方法把条件队列中的线程移到同步队列。理解了这个，ArrayBlockingQueue和CountDownLatch的原理就都能串起来。

6. Spring、MySQL、Redis：项目经验中最常被追问的三驾马车

6.1 Spring Bean生命周期与循环依赖

Spring Bean生命周期可以压缩成一句话：实例化、属性填充、初始化、使用、销毁。中间穿插各种扩展点，比如BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization、InitializingBean的afterPropertiesSet、@PostConstruct等。

循环依赖是Spring面试最常考的点。Spring用三级缓存解决：

• 一级缓存singletonObjects存放完整Bean；
• 二级缓存earlySingletonObjects存放早期暴露的原始Bean；
• 三级缓存singletonFactories存放ObjectFactory。

为什么需要三级而不是两级？关键点是有AOP。一个Bean在创建过程中可能需要被代理，代理对象必须在属性填充之前暴露给依赖方。三级缓存里存的是ObjectFactory，这样可以在对象真正被引用时才决定是否生成代理。如果只有二级缓存，提前暴露出来的原始对象后面无法替换成代理对象，最终会造成类型不匹配。

还要记住：构造器注入的循环依赖无法通过三级缓存解决，多例Bean也不行。出现循环依赖第一反应应该是重构设计，而不是依赖Spring的兜底机制。

6.2 MySQL索引为什么是B+树，以及SQL优化常用手段

MySQL InnoDB索引默认是B+树。为什么不是B树或哈希？哈希适合等值查询，但不适合范围查询和排序；B树叶子节点和非叶子节点都存数据，树相对更高，范围查询要做中序遍历；B+树只有叶子节点存数据，内部节点只存键值，扇出更高、树更矮，而且叶子节点用链表串起来，范围查询非常方便。

面试题里“回表”和“覆盖索引”也要说清楚。二级索引的叶子节点存的是主键值，通过二级索引查数据需要拿到主键再回聚簇索引查一次，这就是回表。覆盖索引是指查询的字段已经在索引的叶子节点里，不需要回表。联合索引还涉及最左前缀原则：比如索引(a,b,c)，查询条件只有b和c时无法走索引，但a和c可以，因为最左列固定住了。

SQL优化一般从EXPLAIN开始。重点关注type字段：从好到差大致是system > const > eq_ref > ref > range > index > all。看到type=all要注意全表扫描，看到Extra=Using filesort或Using temporary要优化排序和分组。实际优化手段包括：加合适的索引、避免select *、少用%xxx%这类无法命中索引的模糊查询、避免在索引列上做函数运算。

MySQL的事务隔离级别也常考。默认是可重复读，靠MVCC和undo log实现。MVCC的ReadView可见性规则是高频追问点，需要理解为什么可重复读下同一个事务多次查询结果一致，而读已提交每次查询都会生成新的ReadView。

6.3 Redis缓存穿透、击穿、雪崩的解决方案

缓存穿透是查询一个一定不存在的数据，请求直接打到数据库，缓存完全失效。方案有两个方向：缓存空值，设置较短过期时间；或者在缓存前加布隆过滤器，快速判断key是否存在。

缓存击穿是某个热点key过期瞬间，大量请求同时打到数据库。解决办法包括：热点数据永不过期；用互斥锁让只有一个请求去重建缓存，其他请求阻塞等待；也可以采用逻辑过期策略，在缓存value里额外存过期时间，获取时发现逻辑过期就异步重建缓存。

缓存雪崩是大量key同时过期，或者Redis节点故障导致缓存集体失效。解决方式：过期时间增加随机值，避免同一时刻大面积过期；多级缓存兜底；Redis高可用集群；必要时在入口做限流和熔断。

面试追问“Redis为什么快”时，不要只答单线程。更完整的回答是：基于内存操作；使用IO多路复用模型处理网络请求，核心命令执行仍然是单线程；数据结构设计高效，比如跳表、压缩列表；单线程避免了锁竞争和线程切换开销。Redis 6.0引入多线程只负责网络IO读写，核心命令执行还是单线程，这个细节能体现你关注新版本变化。

7. 算法与编码题：排序、Lambda、Stream，以及翻车率最高的编译问题

7.1 手写冒泡排序和快速排序，讲到什么程度才算过

冒泡排序是最基础的排序。优化后的写法可以加一个swapped标志，如果某一轮没有发生交换，说明已经有序，提前结束。时间复杂度最坏和平均都是O(n^2)，空间复杂度O(1)。

public static void bubbleSort(int[] arr) { if (arr == null || arr.length < 2) { return; } int n = arr.length; for (int i = 0; i < n - 1; i++) { boolean swapped = false; for (int j = 0; j < n - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; swapped = true; } } if (!swapped) { break; } } }

快速排序是面试手写题中的常客。核心是partition操作，选一个基准值，把小于等于基准值的放左边，大于的放右边，再递归排序左右两部分。平均时间复杂度O(nlogn)，最坏退化成O(n^2)，空间复杂度O(logn)，来自递归栈。

public static void quickSort(int[] arr, int left, int right) { if (left >= right) { return; } int pivot = partition(arr, left, right); quickSort(arr, left, pivot - 1); quickSort(arr, pivot + 1, right); } private static int partition(int[] arr, int left, int right) { int pivotValue = arr[right]; int i = left; for (int j = left; j < right; j++) { if (arr[j] <= pivotValue) { swap(arr, i, j); i++; } } swap(arr, i, right); return i; }

手写快排能过，但最好还能答出优化方式：基准值三数取中、数据规模小时换插入排序、递归到一定程度后改用堆排序防止栈溢出。这会让面试官觉得你不是背代码，而是理解排序过程。

7.2 Lambda与Stream：高频、简洁但容易用错

Java 8引入的函数式接口是Lambda的核心。Predicate<T>做条件判断，Function<T,R>做转换，Consumer<T>做消费，Supplier<T>做生产。Stream就是对集合进行函数式操作的流水线。

常见用法包括：filter过滤、map转换、collect(Collectors.toList())收集、Collectors.groupingBy分组、reduce聚合。例如：

List<String> names = users.stream() .filter(u -> u.getAge() > 18) .map(User::getName) .collect(Collectors.toList()); Map<Integer, List<User>> groupByAge = users.stream() .collect(Collectors.groupingBy(User::getAge));

容易踩的坑有三个：第一，stream只能消费一次，第二次使用会报“stream has already been operated upon or closed”；第二，parallelStream在共享可变状态时会有并发问题，比如往同一个ArrayList里add元素，不一定能体现并行优势；第三，文件IO相关的Stream要放在try-with-resources里，否则底层文件句柄可能不释放。

7.3 编译报错和环境配置：Lombok、source/target 17、JAVA_HOME

这部分不是传统八股文，但面试过程中特别容易翻车，尤其是候选人现场打开代码却编译不过，观感非常差。

Lombok的报错You aren't using a compiler supported by lombok, so lombok will not work，本质是Lombok版本和JDK版本不匹配，或者IDE使用的编译器不是javac。解决方案是升级Lombok到支持当前JDK的版本，同时在IDE里开启Annotation Processing，并在Maven/Gradle依赖中把Lombok声明为provided或compileOnly，避免它被打进最终产物。

“源发行版 17 需要目标发行版 17”这个报错也很常见。原因通常是项目语言级别、Maven编译器插件版本和JDK版本三者不一致。检查思路是：

1. pom.xml中maven-compiler-plugin的source、target、release统一成17；
2. IDEA的Project Structure -> Project SDK和Modules -> Language level设置一致；
3. IDEA的Settings -> Build Tools -> Maven -> Importing里JDK设置正确。

JAVA_HOME配置也是老生常谈。注意要指向JDK安装根目录，不要指到jre，因为javac在JDK里。Path中增加%JAVA_HOME%\bin，然后命令行分别执行java -version和javac -version验证。如果你本机装了多个JDK，可以用SDKMAN或用环境变量手动切换，面试官问到环境问题时不至于手忙脚乱。

8. 复习优先级和时间分配：我的个人建议与一次真实复盘

如果面试时间只剩一周，我的建议是：前两天过Java基础、集合、JVM和并发，把原理看透并整理成自己的话；第三天练手写算法，至少把冒泡、快排、二分查找、链表反转写熟；第四到第六天集中过Spring、MySQL、Redis，每个模块准备一个能落地的项目例子；最后一天做错题复盘和模拟口头复述。

时间更充裕的话，可以每天拆分任务：三分之一时间看原理，三分之一时间手写代码和画图，三分之一时间口头讲给别人听。口头输出非常重要，很多知识点你以为会了，但一开口就卡壳，说明还没有形成稳定的知识链路。

我经常给候选人推荐一个复盘方法：每道题整理成“一句话结论 + 原理支撑 + 项目例子”三件套。比如问到索引：一句话结论是B+树适合范围查询和排序；原理支撑是内部节点只存键、叶子节点链表串联、树高更矮；项目例子是你曾经优化过一条慢SQL，加联合索引后执行时间从几百毫秒降到几十毫秒。这样面试官听到的不只是背出来的概念，而是一套完整思维链路。

我之前面试过一个候选人，HashMap的扩容机制背得很熟练，但问“如果自定义对象作为key，需要重写什么”时愣住了。他说自己刷题的时候只记结论，没想过为什么hashCode必须跟着equals重写。后来他把这个点补上之后，整个集合框架都串起来了。技术面试就是这样，一个“为什么”能撬动一整片知识盲区，所以复习八股文时，永远多问自己一句“为什么是它，而不是别人”。