JDK 1.8 新特性全景复习路径

我能梳理 default 方法的机制

1. 它解决了老接口新增方法会导致所有实现类编译报错的演进痛点
2. 核心机制是在接口中用 default 关键字声明带方法体的方法
3. 边界是它不能完全替代抽象类，因为接口仍不能持有状态（实例变量）
4. 关联到 static 方法，两者都不计入函数式接口的抽象方法数量。

• 探讨接口多继承时 default 方法的“菱形继承”冲突解决方案。
• 结合 Collection 源码分析 stream() 和 parallelStream() 的默认实现原理。
• 对比 default 方法与抽象类普通方法在多态调用时的字节码差异。

演示如何给自定义接口增加带实现的默认方法，让匿名内部类直接复用。

1interface IFormula {
2    double calculate(int a);
3    default double sqrt(int a) {
4        return Math.sqrt(a);
5    }
6}
7IFormula f = new IFormula() {
8    public double calculate(int a) { return a * a; }
9};
10System.out.println(f.sqrt(100));

我能说清 Lambda 的核心

1. 它简化了行为传递的样板代码，替代了特定场景下的匿名内部类
2. 核心机制是把一段逻辑映射到目标函数式接口的唯一抽象方法上
3. 适用边界是它完全依赖目标类型，无法像普通方法那样独立声明
4. 衍生关联是编译器能自动推断入参类型，并支持外部变量捕获。

• 深入探究 invokedynamic 指令在底层是如何在运行时动态生成 Lambda 内部实现类的。
• 比较 Lambda 与匿名内部类在 this 指针指向上的差异。
• 学习高阶函数如何将多个 Lambda 组合成复杂的逻辑流水线。

展示通过逐步省略类型，将 Comparator 从内部类简化为单行 Lambda。

1List<String> names = Arrays.asList("b", "a", "c");
2// 逐步简化：从 带类型的 Lambda 到 省略类型的 Lambda
3names.sort((String s1, String s2) -> s1.compareTo(s2));
4names.sort((s1, s2) -> s1.compareTo(s2));

我能界定函数式接口的边界

1. 定义是仅有一个抽象方法的接口
2. 核心机制是让编译器能将 Lambda 精准映射到该方法
3. 计数规则豁免了带有方法体的 default、static 方法，以及对 java.lang.Object 的覆盖声明
4. 适用误区是认为不加 @FunctionalInterface 就不能写 Lambda，实际上只要满足结构即可，注解仅为校验。

• 阅读 java.util.function 包的源码，分析基础函数式接口的设计模式。
• 了解 JVM 是如何检查和验证函数式接口的（接口初始化过程）。
• 学习如何使用反编译工具查看带 @FunctionalInterface 注解的接口字节码标志。

自定义一个函数式接口，并展示即使有 Object 方法和默认方法，依然符合要求。

1@FunctionalInterface
2interface MyFunc {
3    void doWork(String input);
4    // Object 方法不计入
5    boolean equals(Object obj);
6    // 默认方法不计入
7    default void log() { System.out.println("Logging..."); }
8}

我能推演 :: 的机制

1. 它是 Lambda 的极简版，用于直接引用已有方法
2. 核心机制是编译器根据目标接口的抽象方法签名去匹配引用的方法
3. 适用边界是当 Lambda 体仅仅是单纯的方法调用且参数列表完全匹配时，若包含额外逻辑或复杂的参数前置处理，则不能用 ::
4. 衍生关联到构造函数引用 ::new，它会根据签名匹配对应构造器。

• 探究数组引用 int[]::new 在底层是如何创建数组实例的。
• 对比未绑定实例方法引用（如 String::length）与绑定实例方法引用的参数签位差异。
• 分析在 Stream API 中使用方法引用如何提升管道操作的可读性。

通过 Person::new 创建构造函数引用，让编译器根据工厂接口自动选择匹配的构造器。

1class Person {
2    String name;
3    Person(String name) { this.name = name; }
4}
5interface PersonFactory {
6    Person create(String name);
7}
8// 编译器自动匹配 String 参数的构造函数
9PersonFactory factory = Person::new;
10Person p = factory.create("Alice");

我能辨析 Lambda 的作用域

1. 核心机制是它不创建新的作用域，this 指向宿主类而非匿名对象
2. 对局部变量的边界是只能捕获不可变（effectively final）变量，以解决并发环境下的内存可见性问题
3. 对成员变量和静态变量则拥有完整的读写权限，因为它们通过实例/类本身引用
4. 衍生关联是它无法像内部类那样直接调用宿主接口的 default 方法。

• 深入研究 Lambda 变量捕获在底层字节码中是如何通过隐式传参实现的。
• 探讨在循环中使用 Lambda 捕获循环变量的坑。
• 对比 Java 与其他语言（如 Kotlin、Scala）在闭包变量修改策略上的设计差异。

展示 Lambda 访问局部变量的限制，以及对成员变量和 this 的直接引用。

1int num = 10; // effectively final
2// num++; // 若取消注释，下面 Lambda 会编译报错
3Runnable r = () -> System.out.println(num);
4class Outer {
5    String prefix = "Value:";
6    void process() {
7        // this 指向 Outer 类实例，而非新对象
8        Runnable r2 = () -> System.out.println(this.prefix + num);
9    }
10}

我能归纳四大接口

1. 概念上它们分别代表数学中的断言、映射、生产和消费行为
2. 解决了代码中到处自定义接口的冗余问题
3. 边界是它们都有对应的原始类型（如 IntPredicate）以避免装箱开销
4. 核心机制如 Function 的 andThen 是先执行当前再执行参数，而 compose 是先执行参数（前置函数）再执行当前。

• 探索 BiFunction、BiConsumer 等双参数函数式接口的应用场景。
• 学习 UnaryOperator 和 BinaryOperator 如何简化同类型输入输出的 Function。
• 研究如何自定义具有异常处理能力的函数式接口来包装抛出受检异常的代码。

演示如何使用 Predicate 进行条件组合，以及 Function 的链式类型转换。

1Predicate<String> isLong = s -> s.length() > 5;
2Predicate<String> startsWithA = s -> s.startsWith("A");
3// 两个断言组合
4Predicate<String> combined = isLong.and(startsWithA);
5
6Function<String, Integer> toInt = Integer::parseInt;
7Function<Integer, String> toString = x -> "Num:" + x;
8// 先解析为数字，再转换为字符串
9Function<String, String> pipeline = toInt.andThen(toString);

我能梳理 Stream 的机制

1. 定义上它是一个来自数据源的支持聚合操作的元素序列
2. 核心机制是惰性求值，中间操作只是记录规则，终端操作才触发实际计算
3. 适用边界是它是一次性消耗品，操作完不能复用
4. 衍生关联到 parallelStream，它利用多线程并行切分任务，但要求操作无状态且不干涉数据源。

• 探讨 ForkJoinPool 在 parallelStream 底层的任务窃取机制。
• 深入学习短路终端操作（如 findFirst、anyMatch）是如何提前结束流处理的。
• 研究如何使用 Collector 自定义复杂的归约与分组逻辑。

展示 Stream 的典型链式调用，包括中间操作和触发执行的终端操作。

1List<String> list = Arrays.asList("a1", "a2", "b1", "c2");
2list.stream()
3    .filter(s -> s.startsWith("c")) // 中间操作，暂不执行
4    .map(String::toUpperCase)       // 中间操作，暂不执行
5    .forEach(System.out::println);  // 终端操作，触发整条流水线

我能应用 Map 的增强方法

1. getOrDefault 避免空指针并给出默认值
2. 核心机制 computeIfAbsent 在键缺失时通过 Function 动态计算并放入值
3. merge 的机制是当键存在时用 BiFunction 聚合旧值与新值，不存在则直接插入
4. 边界是在遍历中调用修改方法可能会抛出 ConcurrentModificationException 或引发死循环。

• 研究 ConcurrentHashMap 中 reduce 和 search 等批量并行操作的原理。
• 对比 replace 和 put 在并发环境下的原子性差异。
• 探索 Map.Entry.comparingByValue() 如何配合 Stream 简化 Map 的排序操作。

利用 merge 方法轻松实现词频统计，无需手动判空和合并逻辑。

1Map<String, Integer> wordCount = new HashMap<>();
2for (String word : Arrays.asList("a", "b", "a")) {
3    // 当 key 存在时，将旧值与新值相加；不存在时插入 1
4    wordCount.merge(word, 1, Integer::sum);
5}
6System.out.println(wordCount); // 输出 {a=2, b=1}

我能辨析新旧日期 API

1. 概念上新 API 位于 java.time 包下，采用不可变对象设计
2. 解决了老 Date 可变性导致的并发可见性问题以及 SimpleDateFormat 的线程不安全
3. 核心机制是所有日期加减修改均返回新实例，内部使用 DateTimeFormatter 进行安全解析
4. 边界是 LocalDate 不含时区，而跨时区业务必须使用 ZonedDateTime。

• 研究 Duration 和 Period 在计算时间跨度时的不同应用场景。
• 学习如何使用 Instant 表示机器可读的时间戳。
• 了解如何平滑地将遗留的 Date 对象转换为新的 java.time 实例。

对比旧 API，展示如何使用新 API 安全且优雅地进行日期计算与格式化。

1// 旧 API 可变且危险
2Date oldDate = new Date();
3oldDate.setHours(12);
4
5// 新 API 不可变且线程安全
6LocalDateTime now = LocalDateTime.now();
7LocalDateTime future = now.plusDays(1); // 产生新实例
8String formatted = future.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));