Java面试题 2026：面试官到底问什么，怎么顺利通过

先坦白一件事：我有一道最爱的 Java 面试题。它简单得就像一枚回形针：“== 和 equals() 有什么区别？”

听起来很简单，对吧？学了几周 Java 的人都知道答案。候选人自信满满地回答：“== 比较的是引用，equals() 比较的是内容。”很好。然后我把这段代码拿给对方看：

Integer small1 = 127;
Integer small2 = 127;
Integer big1 = 128;
Integer big2 = 128;

boolean sameSmall = small1 == small2; // true
boolean sameBig = big1 == big2;       // false

接着，整个房间就安静了下来。非常、非常安静。

不是候选人水平差，而是答案是背下来的，没有真正理解原理。Java 会缓存 −128 到 127 之间的 Integer 对象，所以两个 127 是同一个对象，而两个 128 是两个不同的对象。真懂的人十秒钟就能讲清楚，靠背的人会盯着屏幕发很久很久的呆。

这就是 2026 年 Java 开发者面试的真实样子。题目和五年前几乎一样，变的是：现在面试官几乎总会追问一句“为什么？”——而你的第二个回答，立刻就能暴露你是背的还是真懂。

背完一份“Java 面试题 Top 100”八股文就去面试，就像看了几场泰森的比赛录像就敢上拳台。技术上讲，你确实站在拳台上了。可第一个追问砸过来的速度，比你说出“教程里没讲这个”还要快。

下面我们就来拆解：现在的面试官到底问什么、大家最常在哪里栽跟头，以及怎么准备，才能让追问变成加分项，而不是噩梦。

2026年Java面试有哪些变化

一句话总结：Java 面试的核心题目几乎没变，但到了 2026 年，又加上了现代 Java（17、21 和 25）、Spring Boot 4，以及一种新形式——有时允许使用 AI 的现场编程。

三个最大的变化：

• Java 25 是当前的 LTS 版本。 它在 2025 年 9 月发布，是继 Java 21 之后的第一个长期支持版本。面试官越来越多地不只问“Java 8 有什么新特性”，还会问 record、sealed class、模式匹配和虚拟线程。
• Spring Boot 4。 2025 年 11 月与 Spring Framework 7 一起发布：迁移到 Jackson 3、用 JSpecify 注解做空安全、内置 API 版本管理。如果岗位描述里写了 Spring，准备好被问一两道关于这个新大版本的题。
• 面试中的 AI。 一些公司已经允许候选人在技术面试中使用 AI，Canva 更是从 2025 年起直接要求后端、前端和机器学习岗位的候选人使用 AI。但仍有很多公司明确禁止。规则很简单：提前问清楚 HR。

Java开发面试流程是怎样的

通常不是一场谈话，而是好几轮：

1. HR 初筛——聊动机、经历、期望薪资。不写代码，但会确认你是一个正常、靠谱的人。
2. 技术初筛——30–45 分钟的基础知识快问快答，免得工程师把时间浪费在还没准备好的人身上。
3. 技术面试——60–90 分钟：Java 核心、集合、多线程、Spring、数据库，外加无数个“为什么”。
4. 现场编程或带回家的作业——在面试官的注视下解题，或者在家里做。
5. 终面——团队、流程、你怎么处理冲突和截止日期。这里已经没人问 HashMap 了，他们问的是：周五下午六点线上挂了，你怎么办。

初级岗位主要考基础。职级越高，理论越少，越多是聊真实经历：你做过什么、做过哪些决策、在哪里踩过坑。

接下来按主题过一遍 Java 面试题。这不是完整题库，只是最常见的题目，附带简短答案和常见陷阱。想看几百道题的详细解析，可以去看我们 CodeGym 的系列文章 探索 Java 开发人员职位面试中的问题和答案——后面我们还会再提到它。

Java基础面试题：绕不过去的基本功

基本类型和引用类型有什么区别？ 基本类型的变量里存的是数字或字符本身，引用类型的变量里存的是对象的地址，对象本身住在堆上。这又把我们带回了开头那道 Integer 陷阱题。

为什么 String 是不可变的？ 它不可变的程度，堪比组长对“Tab 还是空格”的看法。说正经的：为了安全、为了缓存哈希码，也为了字符串常量池——程序里很多地方可以同时安全地共享同一个字符串。如果你要在循环里一遍遍拼接字符串，请用 StringBuilder，否则每次迭代都会创建一个全新的对象。

equals() 和 hashCode() 有什么关系？ 只有一条规则：equals() 判定相等的对象，hashCode() 必须相同。但不同的对象 hashCode() 相同完全没问题——那只是普通的哈希冲突。重写了 equals() 却忘了 hashCode()，你就稳稳地造出了一批 HashMap “找不到”的对象，哪怕它们明明就在里面。

Java 传对象是按引用传递还是按值传递？ 经典老题，连自信的中级开发都会栽。想出彩的话，就这么说：“Java 永远是按值传递——只不过有时候这个值恰好是一个引用。”听起来像一句心灵鸡汤，但每次都管用。这就是为什么方法能修改传入对象的字段，却没法让外面的变量指向另一个对象。

这个方法返回什么？

static String pick() {
    try {
        return "try";
    } finally {
        return "finally";
    }
}

答案是 "finally"。finally 块一定会执行，它里面的 return 会覆盖 try 里的 return。finally 就像代码评审里的最后一条评论：永远是它说了算。面试官出这道题，不是因为有人该这么写代码，而是想看你是否理解执行顺序。至于“实际项目里能这么写吗？”，正确答案是：不能，永远不能。

异常：哪里会出错，锅由谁来背

异常相关的题看起来很无聊，直到某个被吞掉的 catch 让线上服务挂掉为止。

• 受检异常和非受检异常有什么区别？ 对于受检异常（checked），编译器会强制你要么处理它，要么在 throws 里声明——比如操作文件时的 IOException。非受检异常（unchecked），也就是 RuntimeException 的子类，通常是代码本身的 bug，比如 NullPointerException 或 IllegalArgumentException，编译器不强制你处理。面试时的高分回答还会补一句：受检异常用于程序可以合理恢复的情况，非受检异常是该修的 bug，而不是该 catch 的东西。
• try-with-resources 是干什么的？ 在 try 后面的括号里声明的、实现了 AutoCloseable 的资源都会被自动关闭，哪怕里面抛了异常：

try (var reader = Files.newBufferedReader(Path.of("orders.csv"))) {
    return reader.readLine();
}

再也不用写 finally 块手动 close()，也不用在 finally 里再嵌套一层 try——那是 Java 7 之前的写法。

• 能 catch OutOfMemoryError 吗？ 技术上可以：它是 Throwable 的子类。但 OutOfMemoryError 是 Error，不是 Exception——它意味着程序通常无法优雅处理的问题。为了“继续跑下去”而 catch 它，就像泰坦尼克号都在下沉了，你还在整理甲板上的躺椅。唯一合理的做法是记录日志，然后干净地退出。

面向对象：要举例子，别背定义

这里排名第一的错误，就是用教科书上的定义来回答。“封装就是数据隐藏。”谢谢——可它在你的代码里什么时候派上过用场？

• 抽象类还是接口？ 接口描述对象能做什么，一个类可以实现多个接口。抽象类是带状态和部分实现的公共基础，而且只能继承一个。从 Java 8 开始，接口有了 default 方法，界限变得更模糊了——面试官特别爱问这一点。
• 重载和重写。 重载（overloading）是同名方法、不同参数，在编译期确定。重写（overriding）是子类为父类方法提供新的实现，在运行期确定。
• 怎么让一个类不可变？ 字段都是 private final，没有 setter，类是 final 的或者构造方法是私有的，内部的可变对象在传入和传出时都做拷贝。或者直接用 record——下面会讲。

Java集合面试题：HashMap 必考

如果集合部分只问你一道题，那一定是 HashMap。如果问两道，第二道也还是 HashMap。

HashMap 底层是怎么工作的？ 内部是一个“桶”数组。key 的 hashCode() 决定放进哪个桶，桶里的元素以链表形式存储。如果某个桶里超过八个元素（并且数组已经至少有 64 个桶），链表就会转成红黑树，免得查找性能退化。当数组填满 75%（这是默认的负载因子）时，它会扩容一倍，所有元素重新分布。

接下来是陷阱：

Map<List<Integer>, String> map = new HashMap<>();
List<Integer> key = new ArrayList<>(List.of(1));
map.put(key, "value");

key.add(2);
String found = map.get(key); // null

我们在把 key 放进 map 之后修改了它。它的 hashCode() 变了，于是 HashMap 去另一个桶里找，结果扑了个空。这条记录还在 map 里——只是你再也没法用这个 key 把它取出来了。所以有一条黄金法则：HashMap 的 key 应该是不可变的。

其他常见题目：

• ArrayList 还是 LinkedList？ 实际代码里几乎总是 ArrayList：按索引访问是瞬间完成的，数据在内存里排得也很紧凑。LinkedList 只在通过迭代器频繁往中间插入这种少见场景下才占优。人人都在教科书里见过它，但几乎没人在生产环境里见过——有点像尼斯湖水怪。
• ConcurrentHashMap 还是 Collections.synchronizedMap()？ 两者都是线程安全的，但 synchronizedMap 会锁住整个 map，而 ConcurrentHashMap 允许多个线程并行操作。
• ConcurrentModificationException 是怎么来的？ 用 for-each 遍历集合的同时修改了它。要在遍历时删除元素，请用迭代器或 removeIf()。

Stream API：一行代码，三行追问

面试官爱 Stream，真实项目的代码也爱。只不过用 Stream 很容易写出既漂亮又错误的代码。

• 为什么我的 Stream “什么也没干”？ filter、map、sorted 这类操作是中间操作：它们返回一个新的流，自己不会触发任何执行。Stream 是惰性的：只有遇到终端操作——collect、count、forEach——才开始干活。在那之前，一个元素都不会被处理。陷阱就在这里：写了带 map 的流却忘了终端操作，map 里的代码就永远不会执行。没有终端操作的 Stream，就像周一写的待办清单：写得漂漂亮亮，然后什么也没发生。
• map() 还是 flatMap()？ map 是进来一个元素、出去一个元素。flatMap 把每个元素变成一整个流，再把它们合并成一条流。经典例子是把“列表的列表”拍平：

List<List<String>> teams = List.of(
        List.of("Anna", "Ben"),
        List.of("Vicky"));

List<String> people = teams.stream()
        .flatMap(List::stream)
        .toList(); // [Anna, Ben, Vicky]

• 一个 Stream 能用两次吗？ 不能。执行过终端操作后，流就关闭了，再调用会抛 IllegalStateException。还要用？那就新建一个。
• Optional：大家是怎么把它用坏的？ Optional 对你很坦诚：值可能不存在。最容易毁掉它的方式，就是不加判断直接调用 get()——这不过是戴了副眼镜、贴了假胡子的老朋友 NullPointerException。第二种方式是把 Optional 当成类的字段或方法参数：它本来是为返回值设计的。正确的工具是 orElse、orElseThrow、map 和 ifPresent。
• 什么是函数式接口？ 只有一个抽象方法的接口，比如 Runnable、Comparator 或 Function。正是这类接口可以用 lambda 来实现。@FunctionalInterface 注解不是必须的，但它会让编译器帮你检查确实只有一个抽象方法。

Java多线程面试题：中级候选人的翻车现场

大多数中级候选人就是在这里被筛掉的。因为多线程没法靠小抄背下来——你得真正理解它。还得对它保持一点敬畏：这是一种健康的本能。

• volatile 保证了什么？ 跨线程的可见性：一个线程对 volatile 变量的写入，会立刻对其他线程可见。但 volatile 不保证原子性：count++ 包含读、加、写三步，两个线程仍然可能弄丢某一次更新。
• 什么是 happens-before？ 一条保证某个操作的结果对另一个操作可见的规则。比如，一个线程在释放监视器锁之前做的所有事情，都会被下一个获取这个监视器锁的线程看到。
• 死锁是怎么发生的？ 两个线程以不同的顺序获取同样的几把锁，然后永远互相等待。就像两个超级有礼貌的人在窄走廊里相遇：“您先请”——“不不不，您先请”，一直让到下班。解决办法是统一加锁顺序，而排查死锁可以用 thread dump。
• Runnable 还是 Callable？ Callable 可以返回结果，也可以抛出受检异常。它们通常通过 ExecutorService 来运行，而不是手动 new Thread()。

多线程本身就是个大话题——想深入了解，可以看我们 Java Core 的前 50 个工作面试问题和答案（第 2 部分） 里的多线程章节。

现代Java：2026年面试官会问什么

这部分内容五年前的面试里根本没有，所以它恰好能区分出谁在持续跟进这门语言。

什么是 record？ 一种用于不可变数据的紧凑类：

record Point(int x, int y) {}

一行代码，你就已经有了构造方法、getter x() 和 y()、equals()、hashCode() 和 toString()。所有字段都是 final 的。此刻，Lombok 正在角落里默默收拾行李。它非常适合做 DTO，也很适合做 HashMap 的 key——当然，前提是你的 record 里没有装一个可变的 ArrayList：final 保护的是引用，而不是列表里的内容。

为什么需要 sealed class？ 它显式列出了允许继承它的类。再配合 switch 里的模式匹配，编译器就知道所有可能的分支，如果有哪一种没处理，它会提醒你。

什么是虚拟线程？ 由 JVM 而不是操作系统管理的轻量级线程。一万个不在话下，几十万个也没问题：

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> callSlowService());
    }
}

一道好的面试题是这样问的：什么时候虚拟线程帮不上忙？ 答案：当任务是 CPU 密集型、而不是在等待的时候。虚拟线程擅长的是代码大量时间都在等待的场景——网络、数据库、外部服务。但它没法让计算密集的任务变快，就像新的人体工学椅不会让你写代码更快一样。

给中级候选人的加分项：以前虚拟线程如果在 synchronized 里阻塞，就会被“钉”（pinned）在它的平台线程上，所有优势瞬间归零。Java 24 修复了这个问题，但这个坑仍然值得了解——Java 21 的项目短期内可不会消失。

Java 25 有什么新特性？ 不用把所有变化都背下来，但有几个值得知道。比如，现在可以不声明类、用简化的 main 方法写程序——这是专门为刚开始学这门语言的人设计的。另外，构造方法现在可以在调用 super() 之前执行代码，比如用来校验参数。

JVM和内存

• JVM 内存由哪些区域组成？ 堆，对象住在这里；每个线程的栈，存放局部变量和方法调用；还有元空间（metaspace），存放类的元数据。
• 垃圾回收器是怎么工作的？ 它会清除程序中“活着”的部分已经不再引用的对象。可以把它想象成办公室的保洁阿姨：她只扔没人认领的东西。一个贴着“请勿动”便利贴的杯子会一直留在那儿，哪怕已经放了三年。大多数对象的寿命都很短，所以堆被分成了不同的代：年轻对象回收得频繁又快速，老对象回收得少一些。
• Java 会内存泄漏吗？ 会。只要还有东西引用着某个对象，垃圾回收器就不会清除它。经典例子是一个只往里加、从不清理的静态集合。还是那个贴着便利贴的杯子，只不过有 1 GB 那么大。或者前面那个 key 被改过的 HashMap：记录还在，但你再也取不出来了。

Spring Boot和数据库面试题

如果岗位描述里写了 Spring——而它几乎总是会写（有时感觉连咖啡师的招聘都要求会 Spring）——这部分请单独准备。

• IoC 和 DI 是什么，为什么构造器注入更好？ Spring 自己创建对象，并把依赖交给它们。构造器注入更好，因为依赖一目了然，字段可以是 final 的，而且不用 Spring 也能轻松测试这个类。
• 为什么 @Transactional 不生效？ 经典场景：带 @Transactional 注解的方法，被同一个类里的另一个方法调用。事务是由代理管理的，而类内部的调用直接绕过了代理——就像员工从后门溜进公司，根本没刷工卡。这是中级岗位最常见的题目之一。
• 什么是 N+1 问题？ 你用一条查询加载了 100 个订单，然后又为每个订单单独查一次客户。结果是 101 条查询，而不是一两条。这时候，数据库正在默默流泪。解决办法是 JOIN FETCH 或 EntityGraph。
• 事务隔离级别有哪些？ 从 READ UNCOMMITTED 到 SERIALIZABLE。光列出来不够——你得讲清楚每一级防住了哪些异常：脏读、不可重复读、幻读。
• INNER JOIN 还是 LEFT JOIN？ 想象两张表：客户和订单。INNER JOIN 只保留至少有一个订单的客户——其他人直接从结果里消失。LEFT JOIN 保留所有客户，没有订单的客户在订单列里得到 NULL。一道经典的理解题：怎么找出一个订单都没有的客户？答案：LEFT JOIN，再加上订单表某一列 IS NULL 的条件。
• 为什么需要索引，为什么不能给所有字段都建索引？ 索引就像书的目录，能加快查找：数据库不必把整张表读一遍。但每个索引都会拖慢插入和更新，因为它也要维护，而且还占空间。所以索引是为真实的查询建的，而不是“以防万一”。给所有字段建索引，就像把整本教科书都划上重点：全是重点，也就没有重点了。

如果数据库是你的短板，可以在 CodeGym SQL 课程 里动手练习查询，练到 JOIN 不再让你发怵为止。

Java现场编程面试：Live Coding 与 AI

现场编程是最吓人的环节。在别人的注视下解题压力很大：连一个普通的 for 循环都开始显得可疑。但有个秘密：面试官几乎总是更在意你怎么思考，而不是你的答案对不对。

面试官在现场编程中看重的是：

• 边想边说。 一言不发的候选人是个黑盒。把推理过程说出来的候选人，哪怕卡住了，也展示了自己的思路。
• 先问清需求。 “输入可能是 null 吗？”“数组有多大？”——这不是不懂，而是专业。
• 从简单解法开始。 先让它跑起来，再让它变得最优。一个能跑的暴力解，胜过一个没来得及写完的绝妙想法。

实战拆解：一道现场编程题长什么样

来看一道典型的现场编程题：找出字符串中第一个只出现一次的字符。 对于字符串 "swiss"，答案是 "w"。

第 1 步：问清需求。 写代码之前，先问几个问题。如果没有这样的字符，返回什么？大小写字母算不同字符吗？字符串可能是空的吗？面试官会回答你——同时看到你会考虑边界情况。

第 2 步：简单解法。 对每个字符，扫描整个字符串，数它出现了几次。能用，但复杂度是 O(n²)：碰上一百万个字符的字符串，要跑很久很久。把这一点说出来——面试官想看到你清楚自己方案的代价。

第 3 步：优化。 两遍就够了：第一遍统计所有字符的次数，第二遍找出第一个次数为一的字符。为了保持字符的顺序，用 LinkedHashMap 就行。又因为这样的字符可能不存在，我们返回 Optional，正如 Stream 那一节说好的那样：

static Optional<Character> firstUnique(String text) {
    Map<Character, Integer> counts = new LinkedHashMap<>();
    for (char c : text.toCharArray()) {
        counts.merge(c, 1, Integer::sum);
    }
    for (Map.Entry<Character, Integer> entry : counts.entrySet()) {
        if (entry.getValue() == 1) {
            return Optional.of(entry.getKey());
        }
    }
    return Optional.empty();
}

现在复杂度是 O(n)：每个字符只被处理常数次。

第 4 步：自己测一测。 在脑子里跑几个例子："swiss" 返回 "w"，"aabb" 返回空的 Optional，空字符串也返回空的 Optional。如果面试官问为什么用 LinkedHashMap 而不是 HashMap，你已经有答案了：普通 HashMap 不记住插入顺序，所以“第一个”字符可能是任何一个。

再送你一个能让面试官眼前一亮的加分点：如果第二遍遍历的是字符串本身而不是 map，用普通 HashMap 也完全可以。这时由字符串决定顺序，map 只负责存次数。两个可行方案，加上清楚的取舍理由——这正是面试官在现场编程中想看到的。

这就是现场编程的全部秘密。不是第一次就写出天才解法，而是一条清晰的路径：问清需求，先简单解决，评估复杂度，再优化，最后自测。

那到底能不能用 AI？ 取决于公司，有时还取决于面试轮次。如果允许，面试官通常不看 AI 生成了什么，而是看你怎么用它：你让它做什么、怎么检查结果、能不能发现错误。比如 Canva 就明确说过：重要的不是 AI 替候选人写了什么，而是能读懂生成的代码、理解它、改进它——并解释每一个技术决策。如果你解释不了代码在做什么，那 AI 不是帮了你，而是坑了你。这就像带着一张用你看不懂的语言写的小抄去考试。

说实话，这是我所知道的支持“基础要扎实”的最有力论据。AI 一秒钟就能给你写出一个 key 可变的 HashMap。只有你能发现：它不该这么写。

速查表：Java面试题真正考的是什么

每道面试题背后都有一层隐藏的意图。下面是最常见题目背后的考点：

如何用三周准备Java面试

第 1 周——基础。 Java 核心、面向对象、异常、集合和 Stream API。别光看答案——要写代码。把一个可变的 key 放进 HashMap，看看会发生什么。故意把 equals() 和 hashCode() 写坏，找出哪里会炸。

第 2 周——多线程和现代 Java。 写一个会死锁的程序，然后用 thread dump 把它找出来。把几个类改写成 record。启动一万个虚拟线程，看看它们是怎么运行的。

第 3 周——Spring、数据库和实战练习。 写一个连数据库的小型 Spring Boot 应用，在自己的代码里抓到一次 N+1 问题，然后修好它。一定要做几次模拟面试——找朋友、找导师，实在不行就对着镜子大声练。

最重要的一条：别背答案。这篇文章里的每一道题，都能在五分钟内用代码验证。亲手验证过的东西会一直记得，背下来的东西只能撑到第一个“为什么？”。

到那时，会议室又会安静下来。只不过这一次，是因为面试官已经没什么可补充的了。

去哪里练习

在 CodeGym Java 课程 里，这篇文章中几乎每个主题——从集合、异常到多线程——都有对应的练习题，并且能即时检查。equals() 和 hashCode() 写错了，当场就能发现，而不是等到面试时才暴露。

如果你想在导师的带领下一路走到第一个 offer，还有 Java University：这是一个带导师的项目，目前只提供英文授课，包含代码评审和作品集项目，还有职业中心帮你改简历、准备面试。

还想看更多带详细解析的题目？打开我们 CodeGym 的系列文章 探索 Java 开发人员职位面试中的问题和答案 和 Java 开发人员最常被问到的 150 个求职面试问题。够你刷好多个晚上了。

常见问题（FAQ）

2026 年 Java 面试会问哪些题？ 基础部分不变：Java 核心、面向对象、异常、集合、Stream API、多线程、JVM、Spring 和数据库。到了 2026 年，又加上了现代 Java 的题目——record、sealed class、模式匹配、虚拟线程和 Java 25 的变化——以及 Spring Boot 4。

初级 Java 开发面试一般问什么？ 主要是基础：== 和 equals() 的区别、equals() 和 hashCode() 的关系、String 为什么不可变、HashMap 怎么工作、ArrayList 和 LinkedList 的区别、受检和非受检异常、try-with-resources，以及 Stream API 里的 map() 和 flatMap()。光知道答案不够——你还得解释为什么是这样。

中级 Java 开发会被问哪些面试题？ 多线程（volatile、happens-before、死锁、ExecutorService）、JVM 和垃圾回收器的工作原理、Spring（DI、@Transactional 及其陷阱）、Hibernate（N+1 问题、懒加载）以及事务隔离级别。另外还有大量关于真实项目经验的问题。

Java 面试可以用 AI 吗？ 取决于公司，甚至取决于面试轮次。有些公司允许甚至要求在技术面试中使用 AI，但很多公司仍然禁止。请提前和 HR 确认。如果允许使用 AI，面试官会考察你能否解释和验证生成的代码。

现在面试看哪个 Java 版本？ 当前的 LTS 版本是 2025 年 9 月发布的 Java 25。不过很多公司仍在使用 Java 17 和 21，所以最好也了解这两个版本各自引入了什么。

Java 现场编程面试会出什么题？ 通常是关于字符串、数组和集合的小型算法题：找出第一个不重复的字符、找出数组中的重复元素、判断回文、用 HashMap 对数据分组。面试官不仅看结果，还看你怎么澄清需求、评估复杂度、检查边界情况。

怎样快速准备 Java 面试？ 三周足够把基础好好复习一遍：第一周——Java 核心和集合，第二周——多线程和现代 Java，第三周——Spring、数据库和模拟面试。关键是每个答案都用代码验证，而不是死记硬背。