罗罗编程学习记录
本页内容 展开查看

01.2 阶段 1 Java 语言核心

所属:全栈开发面试题库 / 学习路径 / 01 Java 与 Spring 全栈

本页目录

一、阶段定位

阶段 0 只做到"在命令行 javac 编译、java 运行一个 main"。本阶段开始真正掌握 Java 这门语言的模型:静态强类型、面向对象、集合、泛型、反射、函数式、异常、NIO。重点不是"语法背了多少",而是 Java 与脚本语言的三处硬差异:

  1. 编译期类型检查:泛型、方法重载、异常声明都在编译期决定,写错立刻报错,不会运行到一半才崩。
  2. 集合有明确底层与复杂度:HashMap 是数组+链表+红黑树,ArrayList 是动态数组,选错结构直接影响性能。
  3. 受检异常强制处理: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 分钟内定位

自测题:

  1. new Integer(127) == new Integer(127) 与 Integer.valueOf(127) == Integer.valueOf(127) 各是什么结果?
    • 要点:前者 false(new 新对象);后者 true(缓存 -128~127)。
  2. HashMap 默认容量、负载因子、树化阈值各是多少?
    • 要点:16、0.75、链表长度 ≥8 且数组 ≥64 转红黑树。
  3. 为什么重写 equals 必须重写 hashCode?
    • 要点:HashMap 按 hashCode 定位桶,不重写会让相等对象落到不同桶。
  4. 类型擦除后 List<String> 与 List<Integer> 是同一个类吗?
    • 要点:是,运行期都擦成 List。
  5. JDK 动态代理与 CGLIB 的适用边界?
    • 要点:前者基于接口,后者生成子类(不能 final)。
  6. try-with-resources 关闭多个资源的顺序?
    • 要点:与声明顺序相反,且任一资源关闭异常会被抑制(addSuppressed)。