01.2 阶段 1 Java 语言核心
所属:全栈开发面试题库 / 学习路径 / 01 Java 与 Spring 全栈
本页目录
一、阶段定位
阶段 0 只做到"在命令行 javac 编译、java 运行一个 main"。本阶段开始真正掌握 Java 这门语言的模型:静态强类型、面向对象、集合、泛型、反射、函数式、异常、NIO。重点不是"语法背了多少",而是 Java 与脚本语言的三处硬差异:
- 编译期类型检查:泛型、方法重载、异常声明都在编译期决定,写错立刻报错,不会运行到一半才崩。
- 集合有明确底层与复杂度:
HashMap是数组+链表+红黑树,ArrayList是动态数组,选错结构直接影响性能。 - 受检异常强制处理:
IOException这类异常必须在签名上声明或捕获,绕不过去。
不掌握本阶段,到 阶段 5 Spring 会卡住的具体位置:看不懂 BeanPostProcessor、动态代理、泛型 RestTemplate 的泛型签名;用 HashMap 在并发场景下造成死循环或数据丢失还找不到原因;写 Controller 时 @RequestParam 为 null 不判空直接 NPE;Stream 不会写,业务分组统计还在嵌套 for 循环。
本阶段原有"卡点"要落到现象:(1) 问你 ArrayList.get(i) 的复杂度、HashMap.put 什么时候扩容,你答"都是 O(1)"或答不上来;(2) 泛型报错如 incompatible types: String cannot be converted to int 不会定位是哪一行、哪个类型参数不匹配;(3) 代码里到处 catch (Exception e) {} 空捕获或只 e.printStackTrace()。出现任一现象,先把本阶段补齐再进 阶段 2 JVM。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能写出含类、接口、继承、枚举、record 的命令行程序 | javac 无报错,行为符合预期 |
| 能说清 ArrayList / LinkedList / HashMap 的底层与复杂度,并解释扩容时机 | 手写触发 HashMap 扩容的最小程序 |
| 能定位泛型编译错误,正确使用通配符上下界 | 给出一段报错能指出原因与修法 |
| 能用反射读取类结构、写自定义注解并用代理拦截方法 | 写一个简单的计时代理 |
| 能用 Stream 完成分组、过滤、归约,正确使用 Optional | 一段集合统计代码用 Stream 写出 |
| 能用 try-with-resources 管理资源,异常链不丢失 | 写一个文件读取,异常带原因 |
建议学时:
- 全职(每天 4–6 小时):3 周,约 80–90 小时。语法与 OO 20 小时、集合 20 小时、泛型反射代理 20 小时、Stream 异常 NIO 20 小时、动手 15 小时。
- 在职(每天 2 小时):7–8 周,约 90 小时。有其他语言基础的人可压缩语法部分,但集合与反射不能跳。
学时分配:类型与 OO 15%、集合 25%、泛型 10%、反射代理 15%、Stream/Optional 15%、异常 10%、NIO 与新版本 10%。集合与反射是面试重灾区,时间给够。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 命令行编译运行 | javac/java 跑通 Hello |
01.1 阶段 0 |
| 变量与流程控制 | 知道变量、if/for、方法、返回值 | 01.1 阶段 0 |
| 基本数据表示 | 知道 int、long、String、boolean 的字面量 | 01.1 阶段 0 |
| 十六进制与字节 | 能看懂 0x 前缀 | 01.1 阶段 0 |
经验提示:写过 Python/JS 的人最容易在"null 必须判空""equals 比较字符串""集合泛型"上栽;写过 C++ 的人容易把值语义带到 Java,忘记 Java 对象默认是引用。这两类偏差要主动纠正。
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 类型与 OO | 基本类型与包装类、自动装箱、继承多态、抽象类/接口/枚举/record | 会用 | 04.1 Java |
| 集合 | ArrayList/LinkedList/HashMap/TreeMap/HashSet、fail-fast、equals 与 hashCode | 能讲清原理 | 04.1 Java |
| 泛型 | 泛型类/方法、通配符 ? extends/? super、类型擦除、Bridge 方法 |
能讲清原理 | 04.1 Java |
| 反射与代理 | Class 对象、Method/Field、自定义注解、JDK 动态代理 vs CGLIB | 会用 | 04.1 Java |
| 函数式 | Lambda、方法引用、Stream、Optional | 会用 | 04.1 Java |
| 异常 | 受检/非受检、异常链、try-with-resources | 能讲清原理 | 04.1 Java |
| IO/NIO | BIO/NIO/AIO、Buffer/Channel/Selector、零拷贝 | 了解 | 04.1 Java |
| 新版本 | Java 8→21:record、sealed、模式匹配、switch 表达式、虚拟线程概念 | 了解 | 04.1 Java |
进度建议:集合与泛型两栏达到"能讲清原理"再进阶段 2;其余到"会用"即可。术语定义见《术语表》,不在这里重复抄。
五、分模块精讲
5.1 类型系统、面向对象与新版本语法
为什么需要它:Java 是静态强类型语言,编译期就把类型、重载、重定下来。不搞清"基本类型 vs 引用类型""== vs equals""重写 vs 重载",写出来的代码要么编译不过,要么运行时 NPE。
核心机制:
- 8 种基本类型:
byte/short/int/long/float/double/char/boolean,它们不是对象,存在栈上(局部变量);包装类Integer等是对象,有缓存池(Integer.valueOf缓存 -128 到 127)。 - 自动装箱/拆箱:
Integer i = 10实际调Integer.valueOf(10);循环里对包装类做加减会产生大量临时对象,是性能坑。 ==比较基本类型的值、引用类型的地址;equals默认也是地址,但String、包装类、集合类都重写为内容比较。比较字符串内容必须用s1.equals(s2),常量在前避免 NPE:"admin".equals(name)。- 方法重载看参数列表(编译期),方法重写看子类签名一致(运行期动态分派)。
- Java 16+
record是不可变值类(如record Point(int x, int y){}),自动生成构造器、访问器、equals/hashCode/toString;Java 17+sealed密封类限定可继承范围。
最小可运行示例:
public class TypeDemo {
public static void main(String[] args) {
Integer a = 127, b = 127;
Integer c = 200, d = 200;
System.out.println(a == b); // true:-128~127 走缓存
System.out.println(c == d); // false:超出缓存,新对象
String s1 = "hi", s2 = "hi";
String s3 = new String("hi");
System.out.println(s1 == s2); // true:字符串常量池
System.out.println(s1 == s3); // false:new 在堆上
System.out.println(s1.equals(s3)); // true:内容相等
record User(String name, int age) {} // Java 16+
User u = new User("Ann", 30);
System.out.println(u.name() + " " + u.age());
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 字符串比较永远 false | 用 == 比较 new 出来的字符串 |
用 equals,常量在前 |
Integer 比较结果忽对忽错 |
依赖 -128~127 缓存 |
用 equals 或 intValue() 比较 |
循环里 Long sum += i 很慢 |
每次装箱拆箱产生新对象 | 基本类型 long 累加 |
面试考法:必问"== 与 equals""Integer 缓存""重载与重写"。要答到常量池、IntegerCache、动态分派的边界。
5.2 集合框架与底层复杂度
为什么需要它:集合是业务代码用得最多的结构。选错集合(如遍历时频繁中间插入用 ArrayList)或不知道扩容时机,性能问题就从这来;并发用 HashMap 会在 Java 7 死循环、Java 8 数据丢失。
核心机制:
ArrayList:动态数组,get/set是 O(1),尾部 append 摊销 O(1),中间插入/删除要搬移元素 O(n);扩容默认 1.5 倍(旧容量 + 旧容量右移 1 位)。LinkedList:双向链表,头尾增删 O(1),随机访问get(i)要遍历 O(n)。HashMap(Java 8):数组 + 链表 + 红黑树。默认初始容量 16、负载因子 0.75;链表长度 ≥ 8 且数组长度 ≥ 64 时转红黑树(查询从 O(n) 降到 O(log n));size 超过容量*负载因子翻倍扩容。hash把 hashCode 高 16 位异或到低 16 位,减少碰撞。ConcurrentHashMap:Java 8 放弃分段锁,用CAS + synchronized 锁桶头节点,并发度更高;不允许 null 键值。- fail-fast:遍历时用
iterator.remove()才安全,直接list.remove()会抛ConcurrentModificationException。 - 约定:重写
equals必须重写hashCode,否则作为 HashMap 键会出现"相等的对象散列到不同桶"。
最小可运行示例:
import java.util.*;
public class CollDemo {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < 100; i++) map.put("k" + i, i);
// 正确遍历删除:用迭代器
Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
if (it.next().endsWith("0")) it.remove();
}
// 分组统计:Stream
List<String> words = List.of("apple","banana","apple","cat");
Map<String, Long> freq = words.stream()
.collect(java.util.stream.Collectors.groupingBy(w -> w, java.util.stream.Collectors.counting()));
System.out.println(freq);
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
ConcurrentModificationException |
for-each 里直接 list.remove |
用 Iterator.remove() 或 removeIf |
| HashMap 做键但 equals 相等却查不到 | 没重写 hashCode | 同时重写 equals 与 hashCode |
| 并发 put 偶发数据丢失/CPU 100% | 多线程用 HashMap | 换 ConcurrentHashMap |
get(i) 在大链表上很慢 |
用 LinkedList 随机访问 | 用 ArrayList,或换索引结构 |
面试考法:必问"HashMap 底层""扩容""为什么转红黑树""ConcurrentHashMap 怎么保证线程安全"。要答到数组+链表+红黑树、负载因子 0.75、树化阈值 8、CAS+synchronized。
5.3 泛型与类型擦除
为什么需要它:Spring 里到处是泛型:List<User>、RestExchange、ResponseEntity<T>。不懂擦除,遇到 ClassCastException 在莫名其妙的行、或通配符报错,根本无法定位。
核心机制:
- 泛型只在编译期存在,编译后被擦除:
List<String>与List<Integer>在运行期都是List,对象上没有类型参数信息。 - 擦除规则:无界泛型擦成
Object,有界(<T extends Comparable>)擦成上界。 - 通配符:
? extends T读得出 T、不能写;? super T写得进 T、读出来是 Object。PECS 原则(Producer extends, Consumer super)。 - 不能
new T()、不能new T[10]、基本类型不能做泛型实参(要用Integer)、不能对泛型类做instanceof ArrayList<String>(只到原始类型)。
最小可运行示例:
public class GenericDemo {
// 泛型方法 + 上界
static <T extends Comparable<T>> T max(T a, T b) {
return a.compareTo(b) >= 0 ? a : b;
}
public static void main(String[] args) {
System.out.println(max(3, 7));
// 擦除验证:运行期看不到 String
List<String> strs = new ArrayList<>();
List<Integer> ints = new ArrayList<>();
System.out.println(strs.getClass() == ints.getClass()); // true
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
incompatible types: List<String> cannot be converted to List<Object> |
泛型不协变 | 用 List<? extends Object> 或 List<?> |
往 List<? extends Number> 里 add 报错 |
extends 只能读 | 按 PECS 改通配符 |
ClassCastException 在不显式转换的行 |
桥接方法/擦除 | 检查泛型边界,调用方类型对齐 |
面试考法:问"类型擦除是什么""List<String> 与 List<Object> 的区别""通配符上下界"。要答到运行期无泛型、桥接方法、PECS。
5.4 反射、注解与动态代理
为什么需要它:Spring IoC、MyBatis、序列化框架全部建立在反射与代理之上。不懂反射,就看不懂"为什么一个接口没有实现类也能被注入""AOP 是怎么在方法前后加逻辑的"。
核心机制:
- 拿到
Class:对象.getClass()、类名.class、Class.forName("com.example.User")。 - 反射访问:
getMethod/getDeclaredMethod、Field.setAccessible(true)突破 private。 - 注解:
@Retention(RUNTIME)才能运行期被反射读到;@Target限定可标注位置。 - JDK 动态代理:基于接口,
Proxy.newProxyInstance,目标必须实现接口;CGLIB:生成子类,目标不能是 final,不需要接口。Spring AOP 默认:有接口用 JDK 代理,无接口用 CGLIB(Spring Boot 2.x 起默认 CGLIB)。
最小可运行示例:
import java.lang.reflect.*;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@interface Log { }
class UserService {
@Log public void hello() { System.out.println("hello"); }
}
public class ProxyDemo {
public static void main(String[] args) throws Exception {
// 反射读注解并调用
Method m = UserService.class.getMethod("hello");
if (m.isAnnotationPresent(Log.class)) {
System.out.println("调用前记录日志");
m.invoke(new UserService());
}
// JDK 动态代理(接口示例)
Hello service = (Hello) Proxy.newProxyInstance(
ProxyDemo.class.getClassLoader(),
new Class[]{Hello.class},
(p, method, a) -> {
System.out.println("代理:" + method.getName());
return null;
});
service.say();
}
}
interface Hello { void say(); }
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 反射读不到注解 | 注解保留策略是 CLASS/SOURCE | 改 @Retention(RUNTIME) |
IllegalAccessException |
访问 private 成员 | setAccessible(true) |
| 代理对 final 类/方法无效 | CGLIB 靠继承 | 去掉 final 或换 JDK 接口代理 |
| 自调用时代理不生效 | 内部 this 调用不走代理对象 |
阶段 5 详解,改注入自代理或拆分方法 |
面试考法:问"JDK 动态代理与 CGLIB 区别""Spring 用哪个""反射性能为什么慢"。要答到接口 vs 子类、每次调用有反射开销(可缓存 Method)。
5.5 函数式、Stream 与 Optional
为什么需要它:业务代码里大量"从集合里筛、转、分组、统计",用命令式 for 循环又长又容易出错。Stream 把这类操作声明化;Optional 用来显式表达"可能没有值",消灭一部分 NPE。
核心机制:
- Lambda 是函数式接口的实例(只有一个抽象方法的接口,如
Function、Predicate、Consumer)。 - Stream 分中间操作(
filter/map/sorted,惰性)与终止操作(collect/count/forEach,触发流水线);每个 Stream 只能消费一次。 - 常用收集器:
Collectors.toList()、groupingBy、joining(",")、mapping、partitioningBy。 Optional:用ofNullable包裹可能为 null 的值,用orElse/orElseGet/map/ifPresent链式处理;不要把 Optional 当字段或参数,更不要get()不判空。
最小可运行示例:
import java.util.*;
import java.util.stream.*;
public class StreamDemo {
public static void main(String[] args) {
List<Integer> nums = List.of(3, 1, 4, 1, 5, 9, 2, 6);
List<Integer> top = nums.stream()
.filter(n -> n % 2 == 0)
.sorted()
.map(n -> n * 10)
.collect(Collectors.toList());
System.out.println(top); // [20, 40, 60]
// Optional 正确姿势
String name = null;
String display = Optional.ofNullable(name)
.map(String::trim)
.filter(s -> !s.isEmpty())
.orElse("匿名");
System.out.println(display);
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
IllegalStateException: stream has already been operated upon |
复用同一个 Stream | 每次重新生成 Stream |
NoSuchElementException |
空 Optional 直接 get() |
用 orElse/orElseThrow |
| 大集合 parallel() 反而更慢 | 公共 ForkJoinPool 被阻塞任务占满 | 谨慎并行,CPU 密集才用 |
面试考法:问"Stream 与 for 循环区别""中间操作为什么惰性""Optional 该怎么用"。要答到短路、流水线、Optional 是返回值类型而非字段。
5.6 异常体系与 try-with-resources
为什么需要它:后端服务的稳定性很大程度取决于异常处理。吞异常、只 printStackTrace、丢异常链,都会让线上问题无法定位。
核心机制:
- Throwable 分
Error(JVM 级,如 OOM,不应捕获)与Exception;Exception分受检(IOException、SQLException,编译期强制处理)与非受检(RuntimeException,如 NPE、IllegalArgumentException)。 - 异常链:
catch后抛新异常要把原因传进去:throw new BizException("查订单失败", e),否则根因丢失。 - try-with-resources(Java 7+):实现
AutoCloseable的资源自动关闭,等价于 finally close 且保证多资源逆序关闭。 - 不要
catch (Exception e) {}空块;不要用异常做流程控制。
最小可运行示例:
import java.io.*;
import java.nio.file.*;
public class ExceptionDemo {
static String readFirstLine(String path) throws IOException {
// try-with-resources:br 自动关闭,即使中间抛异常
try (BufferedReader br = Files.newBufferedReader(Paths.get(path))) {
return br.readLine();
} catch (IOException e) {
// 包装并保留根因
throw new IOException("读取文件失败: " + path, e);
}
}
public static void main(String[] args) {
try {
readFirstLine("no.txt");
} catch (Exception e) {
System.out.println(e.getMessage());
System.out.println("根因: " + e.getCause());
}
}
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 日志里只有业务异常没有根因 | catch 后 new 异常没传 e | 用 new Xxx(msg, e) |
| 文件句柄泄漏 | 手动 finally close 写错顺序 | 用 try-with-resources |
| 空 catch 块导致问题被掩盖 | 吞异常 | 至少打日志或抛出 |
面试考法:问"受检与非受检""finally 与 return 的关系""try-with-resources 原理"。要答到异常表、自动生成 finally。
5.7 IO/NIO 与新版本特性速览
为什么需要它:阶段 3 并发、阶段 6 网络、阶段 8 部署都会碰到 BIO/NIO 模型。知道 Selector 是什么,才能理解 Netty、Spring 响应式为什么快。
核心机制:
- BIO:一连接一线程,
read阻塞;连接多了线程爆炸。 - NIO(Java 4):Channel + Buffer + Selector,一个线程轮询多个 Channel(多路复用),连接再多也只需要少量线程。
- AIO(NIO.2):异步通道,读写完成回调,Windows 支持好,Linux 上 Netty 仍用 NIO 模拟。
- 零拷贝:如
FileChannel.transferTo,数据从内核态页缓存直接到网卡,不经过用户态,Kafka 用它。 - 新版本:Java 8 Lambda/Stream;14 switch 表达式;16 record;17 sealed;21 虚拟线程(Loom,见阶段 3)。
最小可运行示例:
// NIO 多路复用骨架(理解模型即可,生产用 Netty)
Selector selector = Selector.open();
ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);
server.socket().bind(new java.net.InetSocketAddress(8080));
server.register(selector, SelectionKey.OP_ACCEPT);
// 循环:selector.select() 拿到就绪的 key,分别处理 accept/read/write
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| BIO 服务连接数一高就 OOM | 每连接一线程 | 换 NIO/Netty 或加线程池 |
| Buffer 读写位置混乱 | flip/clear 忘了调 | 读前 flip,清后 clear |
面试考法:问"BIO/NIO/AIO 区别""零拷贝是什么""虚拟线程解决什么"。要答到同步阻塞 vs 多路复用、内核态不拷贝。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 通讯录 CRUD | 用 HashMap 存联系人,重复键提示、空值拒绝 | 增删改查正确,能说出复杂度 | 4 小时 |
| HashMap 扩容观察 | 循环 put 到 1000 个,打印 size 与容量 | 能解释何时扩容、为何 0.75 | 2 小时 |
| Stream 分组统计 | 对一组订单按用户分组求金额 | 一行 Stream 写出,结果正确 | 2 小时 |
| 反射读注解 | 写 @Log 注解,反射打印被标注方法 |
RUNTIME 保留策略生效 | 2 小时 |
| try-with-resources | 读文件并包装异常链 | 根因可查 | 1 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 修字符串比较 | 把 == 比较改为 equals |
含常量在前的 NPE 防护 | 1 小时 |
| 修遍历删除 | 把 for-each 里 remove 改为迭代器 | 不再抛 ConcurrentModification | 1 小时 |
| 消除装箱开销 | 把 Long sum 循环累加改为原始 long |
用 jmh 或目测分配下降 | 2 小时 |
| 泛型通配符 | 给定 List<Number> 与 List<Integer> 报错,用 PECS 修 |
编译通过,读写语义正确 | 2 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 简易缓存 | 用 HashMap + 过期时间实现内存缓存 | 并发安全、能讲为何选 ConcurrentHashMap | 5 小时 |
| 计时代理 | 用 JDK 动态代理统计方法耗时 | 不修改目标类代码 | 4 小时 |
| 订单统计工具 | 从 CSV 读订单,按状态/地区聚合 | Stream 实现,异常处理完整 | 6 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
NullPointerException at 某行 |
引用为 null 直接解引用 | 看堆栈行号,找出哪个变量为 null | 判空或用 Optional |
ConcurrentModificationException |
遍历时直接改集合 | 看是否 for-each 里 remove | 用迭代器/removeIf |
ClassCastException 莫名行 |
泛型擦除/桥接方法 | 看调用方传入类型 | 对齐泛型实参 |
| 字符串比较结果不对 | 用 == |
看是否 new String 或常量池 | equals |
incompatible types 泛型报错 |
泛型不协变/通配符错 | 看错在哪一个方法调用 | 用 ? extends/? super |
| 反射拿不到 private | 没 setAccessible | 看异常 | setAccessible(true) |
| 流已消费异常 | 复用 Stream | 看是否两次终止操作 | 重新生成 |
| 异常日志无根因 | catch 后没传 e | 看日志 caused by | 包装时带 e |
八、出口条件
全部勾选后进入 阶段 2 JVM 与性能基础。
- [ ] 能写出含 record、枚举、接口的程序,并说清 == 与 equals
- [ ] 能画出 HashMap 结构,说清扩容与树化阈值
- [ ] 能解释类型擦除,用 PECS 写对通配符
- [ ] 能用 JDK 动态代理写一个方法计时
- [ ] 能用 Stream 完成分组统计,用 Optional 处理可空值
- [ ] 能用 try-with-resources 写出带根因的异常包装
- [ ] 排障表随机抽三个能在 5 分钟内定位
自测题:
new Integer(127) == new Integer(127)与Integer.valueOf(127) == Integer.valueOf(127)各是什么结果?- 要点:前者 false(new 新对象);后者 true(缓存 -128~127)。
- HashMap 默认容量、负载因子、树化阈值各是多少?
- 要点:16、0.75、链表长度 ≥8 且数组 ≥64 转红黑树。
- 为什么重写 equals 必须重写 hashCode?
- 要点:HashMap 按 hashCode 定位桶,不重写会让相等对象落到不同桶。
- 类型擦除后
List<String>与List<Integer>是同一个类吗?- 要点:是,运行期都擦成 List。
- JDK 动态代理与 CGLIB 的适用边界?
- 要点:前者基于接口,后者生成子类(不能 final)。
- try-with-resources 关闭多个资源的顺序?
- 要点:与声明顺序相反,且任一资源关闭异常会被抑制(addSuppressed)。