面经复盘：初级 Java 后端（应届/1–3 年）一面二面 + HR 面，八股、手撕与项目怎么答

先交代身份：本文不是我的亲身经历。我做了 8 年 Java 后端，早就过了“应届生一面”的年纪。这篇是根据公开面经整理与改编的一场“初级后端（应届 / 1–3 年）常见的面试”：我翻了牛客上的 Java 面经合集、JavaGuide 的面试准备文章，把里面反复出现的题目、追问方式、手撕题拆出来，按“一面 → 二面 → HR 面”的顺序重新编排，中间的点评是我作为面试过别人的过来人写的。文中说的“某一线互联网公司”“某 SaaS 厂商”都是泛指，不对应任何具体公司或面试官。

初级面试的画风，我用一句话概括：八股是门票，手撕是筛子，项目是放大镜，HR 面是终点线前的最后一个坑。八股答不上来，后面不用聊；手撕写不出来，八股再好也难拿 offer；项目讲不清，面试官就会把你的“熟悉”一个个戳破。下面开始。

一、这类面试的整体流程

不同公司轮数不一样，但公开面经里最常见的形态是：笔试或在线测评 → 一面（技术，40–60 分钟）→ 二面（技术，偏项目 + 场景，也可能是主管面）→ HR 面。有的大厂会有三轮技术，有的中小厂两轮技术合并成一轮。下图是我按这些面经整理的“典型路径”，时长是各面经里常见的量级，不是硬标准。

再补一句我从公开面经里看到的“真实感”：牛客的 Java 面经合集里，有面经写到单场就被追问二十来道题（线程池参数、CAS、ThreadLocal、B+ 树、慢 SQL 之类接连问），也有 20 分钟的短面；手撕题里“最大子数组和”“前 K 个高频元素”这样的 Hot 100 题反复出现。也就是说，题目本身不神秘，神秘的是“连环追问”和“现场写代码”的压力。

二、一面：八股基础（考察目标：你是不是真的学过）

一面官的目标很朴素：花 40 分钟判断你“基础牢不牢、表达清不清、有没有靠谱的学习习惯”。JavaGuide 那篇 2026 面试重点总结里给了一个很直白的优先级：MySQL 和 Redis ≥ Java 基础 > Spring / Spring Boot，并发在中大厂问得更多更难，JVM 主要在部分大厂和中厂出现。下面的题就按这个权重来排。

Q1：HashMap 的底层原理？

参考回答要点（JDK 8 及以后）：

• 数据结构：数组 + 链表 + 红黑树。key 的 hashCode 经过扰动（高 16 位异或低 16 位）后与 (n-1) 做与运算得到下标，所以容量必须是 2 的幂。
• 默认初始容量 16，负载因子 0.75，元素个数超过 容量 × 0.75 就扩容为 2 倍。
• 链表长度达到 8 且数组长度 ≥ 64 时树化；数组还不到 64 时，优先扩容而不是树化。树节点少于 6 个退化回链表。
• 线程不安全：多线程 put 可能丢数据；JDK 7 头插法扩容会形成环，JDK 8 改成尾插避免了死循环，但仍然不安全。

面试官追问：“为什么容量是 2 的幂？”“为什么阈值是 8，退化是 6？”“ConcurrentHashMap 怎么保证线程安全？”

我会怎么答得更好：2 的幂那题，别只说“为了用位运算代替取模”，补一句“扩容时元素要么留在原位置、要么移动到 原位置 + 旧容量，只看多出来的那一位 hash 就行”，这就体现你看过 resize 的逻辑。ConcurrentHashMap 要区分 JDK 7（分段锁 Segment）和 JDK 8+（数组桶头节点 CAS + synchronized 锁桶头），这个版本差异是高频踩坑点。至于“为什么是 8”，官方注释里的解释是基于泊松分布，链表长度到 8 的概率极低，树化只是兜底；答到“兜底”二字就够了，硬编数字容易翻车。

Q2：ArrayList 和 LinkedList 有什么区别？扩容怎么做？

要点：ArrayList 底层是数组，随机访问 O(1)，尾插均摊 O(1)，中间插入 / 删除要移动元素 O(n)；LinkedList 是双向链表，头尾操作 O(1)，但按下标访问 O(n)，而且每个节点有额外的前后指针开销、缓存局部性差。ArrayList 默认第一次 add 时才分配 10 的容量，之后按 1.5 倍扩容（oldCapacity + (oldCapacity >> 1)），扩容本质是 Arrays.copyOf。

追问：“所以实际项目里 LinkedList 什么时候用？”——诚实的回答是：几乎不用。需要队列用 ArrayDeque，需要频繁头部插入且元素大时才考虑链表，而且很多基准测试里 ArrayList 因为局部性反而更快。这种“敢说不用”的回答，比背“链表适合增删”更让面试官眼前一亮。

Q3：线程池的核心参数？拒绝策略？怎么设置线程数？

要点：ThreadPoolExecutor 七个参数：corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。提交任务的顺序：先补核心线程 → 核心线程满了进队列 → 队列满了才扩到最大线程数 → 都满了走拒绝策略。四种内置拒绝策略：AbortPolicy（抛异常，默认）、CallerRunsPolicy（调用者自己跑，天然限流）、DiscardPolicy（静默丢弃）、DiscardOldestPolicy（丢队头再重试）。

追问链：“为什么不推荐 Executors.newFixedThreadPool？”→ 因为它用无界的 LinkedBlockingQueue，任务堆积会 OOM；newCachedThreadPool 最大线程数是 Integer.MAX_VALUE，可能创建海量线程。→ “线程数怎么定？”→ CPU 密集型大约 CPU 核数 + 1；IO 密集型可以按 核数 × (1 + 等待时间/计算时间) 估算，但最终要靠压测和监控调。→ “线程池里任务抛异常怎么办？”→ execute 会让线程死亡并打印堆栈，submit 异常被吞进 Future，要 get 才能看到。

踩坑：很多应届生只背“7 个参数”，被问“核心线程满了、队列也满了，会发生什么”时卡壳。把提交流程画成一张图背下来，比背参数名有用十倍。

Q4：synchronized 和 ReentrantLock 的区别？volatile 能保证什么？

要点：synchronized 是 JVM 关键字，自动加解锁，可重入，JDK 6 之后有锁升级（无锁 → 偏向锁 → 轻量级锁 → 重量级锁；偏向锁在 JDK 15 起默认关闭并被废弃，所以别再把它当必背内容，要标注版本）。ReentrantLock 是 API 层的 AQS 实现，支持可中断、超时获取、公平锁、多个 Condition。volatile 保证可见性和禁止指令重排序，不保证复合操作的原子性（i++ 不是原子的）。

追问：“双重检查锁单例为什么要 volatile？”→ 因为 new 对象分“分配内存 / 初始化 / 赋引用”三步，可能被重排成先赋引用后初始化，别的线程拿到半初始化对象。“CAS 是什么？ABA 问题怎么解？”→ 比较并交换，靠 CPU 原子指令；ABA 用版本号（AtomicStampedReference）。这一串在公开面经里的出场率非常高，我建议你能手写一个双重检查单例。

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {                 // 第一次检查，避免每次都加锁
            synchronized (Singleton.class) {
                if (instance == null) {         // 第二次检查，防止重复创建
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Q5：JVM 内存区域和垃圾回收，OOM 怎么排查？

要点：运行时数据区：程序计数器、虚拟机栈、本地方法栈（线程私有）；堆、方法区（JDK 8 起用元空间 Metaspace，占本地内存）（线程共享）。堆分新生代（Eden + 2 个 Survivor）和老年代。可达性分析判定对象存活，GC Roots 包括栈中引用、静态变量、常量等。JDK 8 默认 Parallel GC，JDK 9 起默认 G1。OOM 常见场景：堆溢出、元空间溢出、栈溢出（StackOverflowError）、直接内存溢出。

追问：“线上 OOM 怎么排查？”→ 参数上提前配好 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=...；用 MAT 或 VisualVM 看 dominator tree，找出占内存最大的对象与 GC Roots 引用链；再结合业务判断是内存泄漏（该释放没释放，比如静态 Map 一直 put）还是单纯容量不够。初级岗答到“会用 jmap/MAT 看 dump”就已经超过平均水平。

Q6：MySQL 索引为什么用 B+ 树？事务隔离级别与 MVCC？

要点：B+ 树非叶子节点只存键，一个页能放更多键，树更矮（三层可以撑起千万到亿级数据），磁盘 IO 次数少；叶子节点用链表串起来，范围查询友好；相比 B 树，查询路径长度稳定。聚簇索引叶子存整行数据，二级索引叶子存主键，所以二级索引查完要回表；覆盖索引可以免回表。最左前缀原则、联合索引失效场景（对列做函数、隐式类型转换、like '%x'）要能举例。

事务 ACID；四个隔离级别：读未提交、读已提交（RC）、可重复读（RR，InnoDB 默认）、串行化。InnoDB 用 undo log 版本链 + ReadView 实现 MVCC：RC 每次读生成新 ReadView，RR 在事务第一次读时生成并复用。redo log 保证持久性（WAL），undo log 保证原子性和 MVCC，binlog 用于主从复制和恢复。

追问：“慢 SQL 怎么定位和优化？”→ 开慢查询日志或看监控 → EXPLAIN 看 type、key、rows、Extra（是否 Using filesort / Using temporary）→ 加合适的联合索引 / 改写 SQL / 避免深分页（用“上次最大 id”游标）。这条在牛客合集里的多家面经中都出现过，属于“必答”。

Q7：Redis 的数据结构、持久化和缓存三兄弟

要点：String / List / Hash / Set / ZSet 及使用场景（计数、队列、对象缓存、去重、排行榜）；ZSet 底层是跳表 + 哈希表（小数据量时用紧凑编码，Redis 7 是 listpack，旧版本是 ziplist）。持久化：RDB 快照（体积小、恢复快、可能丢最近一段数据）和 AOF 日志（更安全，可以重写压缩），生产常两者结合。缓存问题：

追问：“缓存和数据库怎么保持一致？”→ 通常是先更新数据库再删除缓存（Cache Aside），并说明极端并发下仍可能短暂不一致，可用延迟双删、订阅 binlog 异步删除兜底；不要说“绝对一致”，这类题面试官想听的是你知道取舍。

Q8：计算机网络与操作系统的“基本盘”

公开面经里网络题的出镜率很稳定：浏览器输入 URL 到页面渲染发生了什么（DNS → TCP 三次握手 → TLS → HTTP → 渲染）、TCP 与 UDP 区别、三次握手与四次挥手为什么这么设计、HTTP 常见状态码、GET 与 POST 的差别。操作系统方面：进程与线程的区别、死锁的四个必要条件、select / epoll 的区别、进程调度算法。初级面试官不指望你讲内核细节，但期望你能用自己的话把“为什么三次握手而不是两次”讲清楚（防止历史失效的连接请求造成资源浪费，并确认双方收发能力）。

Q9：Spring 的 IoC / AOP / 事务

IoC 是控制反转，Bean 的创建与依赖由容器管理；DI 是实现方式；三级缓存用来解决单例 Bean 的 setter / 字段循环依赖（构造器循环依赖解决不了）。AOP 基于动态代理：有接口默认 JDK 代理，无接口用 CGLIB，Spring Boot 2.x 起默认倾向 CGLIB。@Transactional 失效的典型场景：同类内部调用（不经过代理）、方法不是 public、异常被 try-catch 吞掉、抛出的是受检异常而没配置 rollbackFor、数据库引擎不支持事务。这个“事务失效场景”是初级到中级最爱考的一题，建议背成清单。

三、一面里的手撕：三道高频题（思路 + Java 代码）

公开面经里的手撕题，大多不是什么难题，而是 LeetCode Hot 100 里的中低难度。我看到的具体例子有：最大子数组和（牛客合集里一家做服务端研发的面经写明是 Hot 100 第 53 题）、前 K 个高频元素（在两三家的面经里都出现）、反转链表（另一篇五轮面试的长面经里，一面的算法就是链表反转并强调边界）。JavaGuide 的文章里也提醒过：有的公司很重视代码功底，直接考代码题；有的公司笔试有代码题，面试里更看原理。所以建议至少把 Hot 100 里的数组、链表、堆、二分、滑动窗口、树遍历这几类过一遍。

手撕的答题结构我建议固定成四步：复述题意并确认边界 → 说暴力解与复杂度 → 说优化思路 → 写代码并手动走一个用例。面试官看的不只是“跑没跑通”，更看你的沟通与自检习惯。

手撕 1：最大子数组和（动态规划 / Kadane）

题意：给一个整数数组，找出和最大的连续子数组，返回其和。

思路：暴力是两层循环枚举 O(n²)。优化：设 cur 表示“以当前元素结尾的最大子数组和”，则 cur = max(nums[i], cur + nums[i])，意思是“前面的累加是负担就丢掉”，全局答案取所有 cur 的最大值。时间 O(n)，空间 O(1)。

public int maxSubArray(int[] nums) {
    int cur = nums[0];
    int best = nums[0];
    for (int i = 1; i < nums.length; i++) {
        cur = Math.max(nums[i], cur + nums[i]);
        best = Math.max(best, cur);
    }
    return best;
}

踩坑：不要把 best 初始化成 0——全是负数时答案应该是最大的那个负数。追问：“如果要返回子数组的起止下标怎么改？”→ 记录 cur 重置时的起点，更新 best 时同步记录起止。

手撕 2：前 K 个高频元素（哈希表 + 小顶堆）

题意：给数组和整数 k，返回出现频率最高的 k 个元素。

思路：先用 HashMap 统计频次 O(n)；再维护一个大小为 k 的小顶堆（按频次排序），遍历所有 (元素, 频次)，堆满时如果新元素频次比堆顶大就替换。最终堆里就是前 k 个。时间 O(n log k)，比全排序 O(n log n) 好。进阶还能用桶排序做到 O(n)。

import java.util.*;

public int[] topKFrequent(int[] nums, int k) {
    Map<Integer, Integer> freq = new HashMap<>();
    for (int x : nums) {
        freq.merge(x, 1, Integer::sum);
    }
    // 小顶堆：堆顶是当前 k 个里频次最小的
    PriorityQueue<Map.Entry<Integer, Integer>> heap =
            new PriorityQueue<>((a, b) -> a.getValue() - b.getValue());
    for (Map.Entry<Integer, Integer> e : freq.entrySet()) {
        if (heap.size() < k) {
            heap.offer(e);
        } else if (e.getValue() > heap.peek().getValue()) {
            heap.poll();
            heap.offer(e);
        }
    }
    int[] ans = new int[k];
    for (int i = k - 1; i >= 0; i--) {
        ans[i] = heap.poll().getKey();
    }
    return ans;
}

追问：“为什么用小顶堆不用大顶堆？”——因为我们要淘汰的是当前最小的，堆顶就是淘汰候选；用大顶堆得装下全部元素。“数据量特别大、内存放不下怎么办？”——分片统计 + 归并，或用 Count-Min Sketch 做近似统计。这一问把你从“会做题”拉到“懂工程”。

手撕 3：反转链表（含 K 个一组的延伸）

题意：反转单链表。思路：用 prev、cur 两个指针，每一步先保存 next，再把 cur.next 指向 prev，然后整体前移。重点是先存 next，再改指针，顺序错了链表就断了。

public class ListNode {
    int val;
    ListNode next;
    ListNode(int val) { this.val = val; }
}

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode cur = head;
    while (cur != null) {
        ListNode next = cur.next; // 先保存后继
        cur.next = prev;          // 反转指向
        prev = cur;               // 前移
        cur = next;
    }
    return prev;
}

边界：空链表、单节点。追问：“递归怎么写？”“反转链表 II（指定区间）”“K 个一组反转”。K 个一组的核心是：先探测后面是否还有 k 个节点，够就反转这一段、接上下一段的结果，不够就原样返回。能讲清楚这个“探测再反转”的思路，比现场 bug-free 写出来更重要。

手撕的总体建议：1）写代码之前先说思路；2）变量命名别用 a、b、c；3）写完主动用 2–3 个用例（含空输入、单元素、全负数）走一遍；4）真的写不出来，就把暴力解写完整，并说清优化方向，“给出能跑的次优解”远好于“空白”。

四、二面：项目、场景与学习能力

JavaGuide 里有句话我很认同：项目通常是技术追问的入口。二面（或主管面）多半从“介绍一下你最有代表性的项目”开始，然后顺着你说的每一个名词往下钻。它想验证三件事：你是不是真的做过；你对“为什么这么设计”有没有思考；你出了问题会不会排查。

Q10：介绍一下你的项目（30 秒版 + 3 分钟版）

准备两个版本：30 秒版说“做什么、你负责什么、用了什么技术、最大的成果”；3 分钟版再加“架构图怎么画、你遇到的一个最难的问题、你怎么解决、结果怎么量化”。结构模板：背景与目标 → 我的职责 → 技术方案与取舍 → 遇到的问题与解决 → 结果与反思。

应届生和初级工程师最大的问题是“项目像教程复刻”。JavaGuide 提到，面试官通常理解很多同学是跟着视频学的，区别在于你是否真的学明白、是否在原项目上做过改进并能说出指标。所以哪怕是练手项目，也建议自己加一两个“有数据”的改动：比如给列表接口加了联合索引，把某条 SQL 从 1.2 秒压到 30 毫秒；给热点查询加了缓存，命中率多少；加了全局异常处理和统一响应体。这些在文中被列为常见的优化点，也是最好讲的故事。

Q11：项目里遇到的最难的问题是什么？怎么排查的？

这是二面必考的“行为面试 + 技术”混合题。答法我推荐 STAR 的技术改版：现象（症状 + 指标）→ 假设（我猜了哪几种可能）→ 验证（用什么工具、看什么数据）→ 根因 → 修复 → 复盘（怎么避免再发生）。示例：接口偶发超时 → 猜是慢 SQL / 锁等待 / GC → 看慢日志与 EXPLAIN → 发现缺联合索引且有深分页 → 加索引 + 游标分页 → 加监控告警。

加分：把“猜了但排除的方向”也讲出来，这比只讲结论更显得你有方法。禁忌：编造根本没有做过的“百万 QPS 优化”。面试官只要追问两层，比如“峰值是多少、机器几台、瓶颈在哪一层、怎么压测的”，编造的就会露馅。我做过面试官，看到过好几次简历上写“QPS 过万”而说不出压测方法的情况，后果是整份简历的可信度一起被扣分。

Q12：场景题——秒杀 / 订单超时取消 / 短链接 / 限流，你怎么设计？

初级岗的场景题一般难度有限，考的是“思路是否完整”。以“下单扣库存怎么防超卖”为例，答题可以分三层：

• 基础解：数据库层面 update stock set n = n - 1 where id = ? and n > 0，靠行锁保证不超卖；
• 提升：热点商品用 Redis 预扣库存（Lua 保证原子），异步落库；
• 兜底：订单幂等（唯一订单号 / 去重表）、消息队列削峰、超时未支付回补库存（延迟队列或定时任务）。

“消息队列怎么保证不丢、不重复”也是高频追问：生产端确认 + 重试，Broker 持久化 + 副本，消费端手动 ack；重复消费用业务幂等（唯一键 / 状态机）来兜，不要承诺“Exactly Once”。这些话术在中高级面经里更常见，但初级里如果你能主动带出“幂等”这个词，会显得很成熟。

Q13：你平时怎么学习？怎么使用 AI 工具？

这几年二面里多了一个新问法：“你写代码时会用 AI 吗？怎么保证它写的代码是对的？”这不是陷阱，面试官想看的是你有没有判断力。稳妥的答法：会用，主要做样板代码、单测草稿、报错解读、方案对比；但每一段都自己读懂、跑测试、对着文档核对版本和 API，涉及并发、事务、安全的部分绝不盲信；并举一个“AI 给的答案有坑，我是怎么发现的”的真实例子（比如它给了已经废弃的 API，或者忽略了幂等）。

学习能力的其它问法：“最近读了什么技术文章 / 源码”“怎么快速学一个新框架”。建议准备：一个你读过源码的点（比如 HashMap 的 resize 或线程池的 runWorker）、一个你做过笔记的知识体系、一个你踩坑后写的复盘。“有产出的学习”比“看了很多”有说服力。如果你的项目里写了 AI Agent，JavaGuide 特别提示要能讲清 Agent 的工作流和失败恢复。

Q14：“你有什么想问我的？”

别说“没有”。可问：团队目前的技术栈和上线流程？新人前三个月会做什么？团队怎么做 code review 和值班？这几个问题既显示你在意成长，又能帮你判断团队质量。不要在技术面问薪资，那是 HR 面的事。

五、HR 面：动机、期望与 offer

HR 面经常被忽视，却是“技术过了，最后被刷”的重灾区。公开面经里 HR 面反复出现的问题：为什么选择我们公司 / 这个岗位、为什么离职（社招）、职业规划、优缺点、如何与同事沟通并举例、是否有其他 offer、期望薪资、什么时候能到岗、能接受加班或出差吗。牛客上的一篇大厂社招面经还记录了 HR 会问“对这个业务领域是否感兴趣”“Java 与 Go 的看法”这类偏倾向的问题。

答题原则：

• 动机要具体：“喜欢你们的技术氛围”太空。换成“我在项目里做过缓存和消息队列，看到贵团队的订单/交易场景正好需要这类高并发处理，想在真实业务里练手”。
• 优缺点要真实但可控：缺点选“不致命且你已经在改进”的，比如“容易在细节上纠结，现在会先定 deadline 再迭代”。
• 沟通题用真实例子：一个具体的分歧场景 + 你怎么用数据/文档说服对方。
• 期望薪资：先用市场数据做锚点，见下。

关于行情，我读了代码随想录和卡码笔记发布的 2026 届校招薪资报告（样本来自知识星球近千个 offer 的对比，属于特定社群的样本，不代表全行业）：后端一线大厂核心部门大致是“25k–30k × 15–20 薪”，普通业务或区域岗位大致“18k–23k × 14–16 薪”，广告、搜索、交易等方向高于常规 CRUD 业务；总体趋势写的是“高端岗位依然坚挺，普通岗位略有回落”。报告里还提醒：不要只看月薪，要看总包结构；谈判需要筹码，比如竞争 offer、高质量实习或项目、面试评价好、岗位有真实 HC；如果 HR 说 base 动不了，可以尝试争取签字费，尤其是你手上有同档竞争 offer 的时候。这些数字只做参考，请以自己拿到的书面 offer 为准。

另外一个我想强调的细节：问清楚 offer 里的“薪资构成”——月薪 × 月数、绩效比例、是否有股票或补贴、试用期是否打折、公积金基数。口头说的“总包”不算数，要落到书面。

六、这几轮面试暴露的通用规律

七、复盘清单与准备建议

把 JavaGuide 的备战思路和我自己的经验合并，给初级同学一份能落地的清单（时间不够就按 JavaGuide 的 4 周压缩版走，系统学习则用 8 周标准版）：

1. 先把项目讲顺：写出 30 秒和 3 分钟两个版本，并给每个项目准备一个“最难的问题 + 指标”。
2. 主攻高频三件套：MySQL（索引、事务、MVCC、慢 SQL）、Redis（结构、持久化、缓存问题、一致性）、Java 基础与并发（集合、线程池、锁）。
3. Spring 只深挖用过的：IoC / AOP / 事务失效清单 / 自动配置原理。
4. 手撕每周 10 题：按类型刷，每题都要能口述复杂度并手动走用例。
5. 补计算机基础：TCP、HTTP、OS 的“基本盘”，各准备一页笔记。
6. 模拟面试：找朋友或对着录屏讲，练“先说结论再展开”。
7. HR 面材料：动机、优缺点、沟通案例、期望薪资与底线，各写三句话。
8. 投递节奏：先拿小厂练手再冲目标公司，面完当天写复盘（哪题没答好、追问到了哪一层）。

最后是一个小提醒：面试是双向选择。你也在观察面试官是不是认真读过你的简历、问题是不是有逻辑、团队是不是愿意教新人。遇到全程羞辱式提问的，不去也罢。

一句话备忘：初级面试 = 八股连环问（MySQL/Redis 优先）+ Hot 100 中低难度手撕 + 每个名词都要经得起追问的项目 + 一场要提前想好的 HR 面；答不出就说思路，编造永远比不会更危险。

写到这里我想起自己当年第一次面试，线程池七个参数背得滚瓜烂熟，被问“队列满了之后呢”直接沉默了三秒——那三秒比后来所有线上故障都漫长。希望这篇整理能让你的三秒少一点。

参考资料

• 牛客网「Java 工程师精选面经合集」：我打开阅读了其中多家公司的面经摘要，本文的手撕题（最大子数组和、前 K 个高频元素）和“单场追问二十多题”的描述参考了这里，页面未统一标注年份，我只取其题目类型。
• JavaGuide：2026 最新版 Java 后端面试重点总结：MySQL/Redis/Java 基础/Spring 的复习优先级、校招与社招差异、对算法的不同要求。
• JavaGuide：2026 最新版 Java 后端面试通关计划：4 周压缩版与 8 周标准版的阶段划分，以及“项目是追问入口”的提法。
• JavaGuide：项目经历准备指南：30 秒与 3 分钟两个版本、常见项目优化点，以及 AI Agent 项目需要讲清工作流与失败恢复。
• 代码随想录：2026 届计算机应届毕业生薪资报告：后端薪资区间和谈判建议的来源，样本为特定社群。
• 卡码笔记：2026 校招薪资报告：与上一条互相印证的后端与 AI 岗位薪资区间、趋势结论。
• Java 面试题指南：五轮阿里 Java 后端社招面试：一面反转链表与 TCP 基础、二面 MySQL/MQ 等追问，页面未标注明确年份，仅用作题型参考。
• 牛客：阿里 Java 后端社招面经：HR 面常见问题（动机、Java 与 Go、薪资期望）的来源，页面同样未明确年份。