【阶段 0】Java 前置基础：从语法到生产级代码

# 安装 Temurin 仓库后执行
sudo apt-get update
sudo apt-get install -y temurin-17-jdk

brew install --cask temurin@17

# 替换成你实际的安装路径（可用 `readlink -f $(which java)` 查到）
export JAVA_HOME=/usr/lib/jvm/temurin-17-jdk-amd64
export PATH=$JAVA_HOME/bin:$PATH

source ~/.bashrc   # 让配置立即生效

java -version
# 期望输出类似：
# openjdk version "17.0.12" 2024-07-16
# OpenJDK Runtime Environment Temurin-17.0.12+7 (build 17.0.12+7)
# OpenJDK 64-Bit Server VM Temurin-17.0.12+7 (build 17.0.12+7)

javac -version   # javac 17.0.12

mvn -version
# Apache Maven 3.9.x ...

// HelloWorld.java —— JDK 11+ 支持直接 `java HelloWorld.java` 单文件运行，无需先 javac
public class HelloWorld {
    public static void main(String[] args) {
        // println 是 System.out 的静态调用；生产代码禁止用 System.out 打日志，见第 5 章
        System.out.println("Hello, Java 17!");
    }
}

# 方式一：传统两步（编译 + 运行）
javac HelloWorld.java      # 生成 HelloWorld.class 字节码
java HelloWorld            # 运行字节码，输出 Hello, Java 17!

# 方式二：单文件源码启动（JDK 11+ 特性，适合快速验证）
java HelloWorld.java

// DebugDemo.java —— 一个刻意写错的累加逻辑，用来演示断点
public class DebugDemo {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        int sum = sumEven(nums);   // 期望只累加偶数，结果却不对
        System.out.println("偶数之和 = " + sum);
    }

    // 注意：循环里 i++ 与 i+=2 的边界差异，故意留 bug
    private static int sumEven(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];          // 这里没判断奇偶，是 bug
        }
        return sum;
    }
}

# -d 指定 .class 输出目录；-cp 指定运行时 classpath
javac -d out ErrorCode.java BizException.java BizDemo.java
java -cp out BizDemo

// OopDemo.java —— 类 / 继承 / 多态 / 抽象类 / 接口 的最小可用示例
public class OopDemo {

    // 抽象类：不能 new，抽取公共状态与模板方法
    abstract static class Animal {
        protected String name;
        Animal(String name) { this.name = name; }
        abstract String sound();          // 抽象方法，子类必须实现
        String introduce() {              // 模板方法：复用不变逻辑
            return name + " 叫：" + sound();
        }
    }

    // 接口：定义能力契约，可多实现（Java 类是单继承、接口多实现）
    interface Pet {
        void play();                       // 接口方法默认 public abstract
    }

    // 子类：继承抽象类 + 实现接口
    static class Dog extends Animal implements Pet {
        Dog(String name) { super(name); }
        @Override String sound() { return "汪汪"; }
        @Override public void play() { System.out.println(name + " 在接飞盘"); }
    }

    static class Cat extends Animal implements Pet {
        Cat(String name) { super(name); }
        @Override String sound() { return "喵喵"; }
        @Override public void play() { System.out.println(name + " 在玩毛线球"); }
    }

    public static void main(String[] args) {
        // 多态：父类引用指向子类对象，运行时才决定调用哪个实现
        Animal a1 = new Dog("旺财");
        Animal a2 = new Cat("咪咪");
        System.out.println(a1.introduce());   // 旺财 叫：汪汪
        System.out.println(a2.introduce());   // 咪咪 叫：喵喵
        ((Pet) a1).play();                     // 转型到接口，调用 play
    }
}

// User.java —— 生产级：正确重写 equals / hashCode（用 Objects 工具类，规避 null 判断）
import java.util.Objects;

public class User {
    private Long id;          // 数据库主键，业务上唯一标识
    private String username;
    private Integer age;

    public User(Long id, String username, Integer age) {
        this.id = id;
        this.username = username;
        this.age = age;
    }

    // equals：先比引用，再判类型，最后逐字段比对（关键字段是业务主键 id）
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;                 // 同一引用，直接相等
        if (!(o instanceof User)) return false;      // 类型不符，直接不等（instanceof 天然防空）
        User user = (User) o;
        return Objects.equals(id, user.id);          // Objects.equals 内部处理 null，避免 NPE
    }

    // hashCode：与 equals 用到的字段保持一致（都用 id）
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    public Long getId() { return id; }
    public String getUsername() { return username; }
    public Integer getAge() { return age; }

    @Override
    public String toString() {
        return "User{id=" + id + ", username='" + username + "', age=" + age + '}';
    }
}

// MapTraverseDemo.java —— 三种遍历方式的性能与可读性对比
import java.util.HashMap;
import java.util.Map;

public class MapTraverseDemo {
    public static void main(String[] args) {
        Map<Long, User> userMap = new HashMap<>();
        userMap.put(1L, new User(1L, "张三", 25));
        userMap.put(2L, new User(2L, "李四", 30));
        userMap.put(3L, new User(3L, "王五", 28));

        // 方式一（推荐）：entrySet —— 一次拿到 key 和 value，无需二次哈希
        for (Map.Entry<Long, User> entry : userMap.entrySet()) {
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }

        // 方式二（不推荐）：keySet 再 get —— 每次 get 都要再哈希定位一次桶，性能差
        for (Long id : userMap.keySet()) {
            System.out.println(id + " -> " + userMap.get(id));
        }

        // 方式三（JDK8+，最简洁）：forEach + Lambda
        userMap.forEach((id, user) -> System.out.println(id + " -> " + user));
    }
}

// RemoveDemo.java —— 遍历时删除元素会抛 ConcurrentModificationException
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class RemoveDemo {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("张三", "李四", "王五"));

        // 错误写法：for-each 里直接 list.remove，会抛 ConcurrentModificationException
        // for (String name : names) {
        //     if ("李四".equals(name)) names.remove(name);
        // }

        // 正确写法一：removeIf（JDK8+，最推荐，语义清晰）
        names.removeIf("李四"::equals);

        // 正确写法二：Iterator.remove（需要边遍历边做更多逻辑时）
        Iterator<String> it = names.iterator();
        while (it.hasNext()) {
            if ("王五".equals(it.next())) {
                it.remove();
            }
        }
        System.out.println(names);   // [张三]
    }
}

// StringMoneyDemo.java —— String 三兄弟 + BigDecimal 金额
import java.math.BigDecimal;

public class StringMoneyDemo {
    public static void main(String[] args) {
        // String 不可变；循环拼接会不断创建中间对象，必须用 StringBuilder
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10000; i++) {
            sb.append(i).append(',');
        }
        String joined = sb.toString();

        // 错误：new BigDecimal(double) 会引入二进制浮点误差
        BigDecimal wrong = new BigDecimal(0.1);
        System.out.println(wrong);   // 0.1000000000000000055511151231257827021181583404541015625

        // 正确：用字符串构造 或 BigDecimal.valueOf（内部也是字符串构造）
        BigDecimal right = BigDecimal.valueOf(0.1);
        System.out.println(right);   // 0.1

        // 金额比较必须用 compareTo，不能用 equals（equals 会比较 scale 小数位数）
        BigDecimal a = new BigDecimal("10.0");
        BigDecimal b = new BigDecimal("10.00");
        System.out.println(a.equals(b));          // false（scale 不同）
        System.out.println(a.compareTo(b) == 0);  // true（数值相等）
    }
}

// 生产技巧：预分配容量，避免频繁扩容复制
List<User> users = new ArrayList<>(1000);   // 预估 1000 条，一次到位

// LruCacheDemo.java —— 用 LinkedHashMap 实现 LRU 缓存（面试高频手写题）
import java.util.LinkedHashMap;
import java.util.Map;

public class LruCacheDemo {
    public static void main(String[] args) {
        // accessOrder=true：按访问顺序排序；重写 removeEldestEntry 实现容量上限
        Map<String, String> lru = new LinkedHashMap<>(16, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
                return size() > 3;          // 超过 3 条就淘汰最久未访问的
            }
        };

        lru.put("a", "1");
        lru.put("b", "2");
        lru.put("c", "3");
        lru.get("a");                        // 访问 a，a 变「最新」
        lru.put("d", "4");                   // 触发淘汰，最久未访问的 b 被移除

        System.out.println(lru.keySet());    // [c, a, d]（b 被淘汰）
    }
}

// SortDemo.java —— Comparator 外部排序（生产最常用）
import java.util.*;

public class SortDemo {
    record Person(Long id, String name, Integer age) {}

    public static void main(String[] args) {
        List<Person> people = new ArrayList<>(List.of(
            new Person(2L, "李四", 30),
            new Person(1L, "张三", 25),
            new Person(3L, "王五", 25)
        ));

        // Comparator：按年龄升序，年龄相同按姓名升序（生产常用）
        people.sort(Comparator.comparing(Person::age).thenComparing(Person::name));
        System.out.println(people);

        // 按年龄降序
        people.sort(Comparator.comparing(Person::age).reversed());
        System.out.println(people);
    }
}

// ImmutableDemo.java —— 不可变集合
import java.util.*;

public class ImmutableDemo {
    public static void main(String[] args) {
        List<String> names = List.of("张三", "李四");   // 不可变，且不允许 null 元素
        // names.add("王五");                          // 抛 UnsupportedOperationException

        // 把可变集合包成只读视图（内部数据变化仍会反映，但不能通过该视图修改）
        List<String> mutable = new ArrayList<>(List.of("a", "b"));
        List<String> unmodifiable = Collections.unmodifiableList(mutable);
        // unmodifiable.add("c");                      // 抛异常
        System.out.println(unmodifiable);
    }
}

// GenericDemo.java —— 泛型类、泛型方法、通配符的最小可用示例
import java.util.ArrayList;
import java.util.List;

public class GenericDemo {

    // 泛型类：类名后声明类型参数，实例化时确定具体类型
    static class Box<T> {
        private T value;
        Box(T value) { this.value = value; }
        T get() { return value; }
        void set(T value) { this.value = value; }
    }

    // 泛型方法：返回值前声明 <T>，让方法独立于类的类型参数
    static <T> T firstOrNull(List<T> list) {
        return list.isEmpty() ? null : list.get(0);
    }

    // PECS-生产者 extends：只从 list 读元素，不能往里写（因为不知道具体子类型）
    static double sum(List<? extends Number> list) {
        double total = 0;
        for (Number n : list) total += n.doubleValue();
        return total;
    }

    // PECS-消费者 super：只往 list 写元素，读出来只能是 Object（因为不知道具体父类型）
    static void addIntegers(List<? super Integer> list) {
        list.add(1);
        list.add(2);
    }

    public static void main(String[] args) {
        Box<String> box = new Box<>("hello");   // 菱形语法，右侧自动推断
        System.out.println(box.get());

        System.out.println(firstOrNull(List.of("a", "b")));   // 编译期保证类型安全

        System.out.println(sum(List.of(1, 2, 3.5)));          // 9.5

        List<Number> nums = new ArrayList<>();
        addIntegers(nums);                                    // List<? super Integer> 可接 List<Number>
        System.out.println(nums);                             // [1, 2]
    }
}

// ErasureDemo.java —— 类型擦除带来的三个限制（都编译不过，理解即可，不用跑）
public class ErasureDemo {
    // 限制 1：不能 new T()（运行时不知道 T 是什么，无法实例化）
    // static <T> T create() { return new T(); }

    // 限制 2：不能 instanceof T（运行时 T 已被擦除为 Object）
    // static <T> boolean isInstance(Object o) { return o instanceof T; }

    // 限制 3：不能重载「仅泛型参数不同」的方法（擦除后签名相同，冲突）
    // static void print(List<String> list) {}
    // static void print(List<Integer> list) {}

    // 限制 4：泛型不能是基本类型（int 要装箱成 Integer）
    // List<int> list = new ArrayList<>();  // 错误，要用 List<Integer>
}

// Idempotent.java —— 幂等注解：标记「这个方法需要保证幂等（重复调用结果不变）」
import java.lang.annotation.*;

@Target(ElementType.METHOD)          // 只能加在方法上
@Retention(RetentionPolicy.RUNTIME)  // 运行时可反射读取（AOP 依赖这个）
@Documented
public @interface Idempotent {
    String key() default "";         // 幂等键的表达式，如 "#orderNo"（SpEL 风格占位）
    long expire() default 10;        // 幂等记录的过期时间，单位秒
}

// OrderService.java —— 使用幂等注解的最小示例
public class OrderService {
    @Idempotent(key = "#orderNo", expire = 60)
    public void createOrder(String orderNo) {
        // 业务逻辑：下单
        System.out.println("创建订单：" + orderNo);
    }
}

// ReflectDemo.java —— 反射读取自定义注解 + 调用私有方法
import java.lang.reflect.Method;

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 1. 拿到方法对象（这里演示读 OrderService 上的幂等注解）
        Method method = OrderService.class.getMethod("createOrder", String.class);
        Idempotent anno = method.getAnnotation(Idempotent.class);
        System.out.println("幂等键表达式 = " + anno.key() + "，过期秒数 = " + anno.expire());

        // 2. 调用私有方法（生产框架里 setAccessible 很常见）
        Method secret = SecretHolder.class.getDeclaredMethod("secret");
        secret.setAccessible(true);                        // 突破 private 访问限制
        System.out.println(secret.invoke(new SecretHolder()));
    }
}

class SecretHolder {
    private String secret() { return "反射破开了 private"; }
}

// BeanMapConverter.java —— 反射实现 对象 <-> Map 互转（生产级：异常处理 + 嵌套处理）
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

public final class BeanMapConverter {

    // 禁止实例化工具类（私有构造器，阿里手册规范）
    private BeanMapConverter() {}

    /** 对象转 Map：只取非静态字段，key 为字段名，value 为字段值（null 跳过） */
    public static Map<String, Object> toMap(Object obj) {
        if (obj == null) {
            throw new IllegalArgumentException("入参对象不能为 null");
        }
        Map<String, Object> map = new HashMap<>();
        // getDeclaredFields 拿到所有字段（含 private），getFields 只能拿 public
        for (Field field : obj.getClass().getDeclaredFields()) {
            // 跳过静态字段和编译器生成的合成字段，避免污染
            if (Modifier.isStatic(field.getModifiers()) || field.isSynthetic()) {
                continue;
            }
            try {
                field.setAccessible(true);               // 允许读取 private 字段
                Object value = field.get(obj);
                if (value != null) {                     // 跳过 null，避免 Map 里出现脏 key
                    map.put(field.getName(), value);
                }
            } catch (IllegalAccessException e) {
                // 理论上 setAccessible 后不会发生，防御式兜底
                throw new IllegalStateException("读取字段失败: " + field.getName(), e);
            }
        }
        return map;
    }

    /** Map 转对象：按字段名回填，只设置 Map 里存在的 key */
    public static <T> T fromMap(Map<String, Object> map, Class<T> clazz) {
        if (map == null || clazz == null) {
            throw new IllegalArgumentException("map 与 clazz 均不能为 null");
        }
        try {
            // 类型擦除的补偿：显式传入 Class<T>，运行时才知道要 new 什么
            T instance = clazz.getDeclaredConstructor().newInstance();
            for (Field field : clazz.getDeclaredFields()) {
                if (Modifier.isStatic(field.getModifiers()) || field.isSynthetic()) {
                    continue;
                }
                Object value = map.get(field.getName());
                if (value != null) {
                    field.setAccessible(true);
                    field.set(instance, value);
                }
            }
            return instance;
        } catch (Exception e) {
            // 反射的 checked 异常统一包装成运行时异常，保留原始异常链
            throw new IllegalStateException("Map 转对象失败: " + clazz.getName(), e);
        }
    }
}

// ConverterTest.java —— 验证工具类
import java.util.Map;

public class ConverterTest {
    public static void main(String[] args) {
        User user = new User(1L, "张三", 25);
        Map<String, Object> map = BeanMapConverter.toMap(user);
        System.out.println(map);                          // {id=1, username=张三, age=25}

        User restored = BeanMapConverter.fromMap(map, User.class);
        System.out.println(restored);                     // User{id=1, username='张三', age=25}
        System.out.println(restored.equals(user));        // true（equals 只比 id）
    }
}

javac -d out User.java BeanMapConverter.java ConverterTest.java
java -cp out ConverterTest

// DynamicProxyDemo.java —— JDK 动态代理：无侵入地给方法加日志
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxyDemo {

    interface UserService {
        void save(String name);
    }

    static class UserServiceImpl implements UserService {
        @Override public void save(String name) {
            System.out.println("保存用户: " + name);
        }
    }

    public static void main(String[] args) {
        // 目标对象
        UserService target = new UserServiceImpl();

        // 动态生成代理对象（JDK 代理要求目标实现接口）
        UserService proxy = (UserService) Proxy.newProxyInstance(
            DynamicProxyDemo.class.getClassLoader(),
            new Class<?>[]{UserService.class},
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxyObj, Method method, Object[] args) throws Throwable {
                    System.out.println("[代理] 调用前: " + method.getName());   // 横切逻辑：日志
                    Object result = method.invoke(target, args);               // 调用真实方法
                    System.out.println("[代理] 调用后: " + method.getName());
                    return result;
                }
            }
        );

        proxy.save("张三");
        // 输出：
        // [代理] 调用前: save
        // 保存用户: 张三
        // [代理] 调用后: save
    }
}

// RepeatableDemo.java —— 可重复注解
import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Tags.class)              // 声明容器注解，才能重复标注
@interface Tag { String value(); }

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Tags { Tag[] value(); }   // 容器注解：持有多个 Tag

@Tag("缓存")
@Tag("核心")
class Article {}

public class RepeatableDemo {
    public static void main(String[] args) {
        for (Tag t : Article.class.getAnnotationsByType(Tag.class)) {
            System.out.println(t.value());   // 缓存 / 核心
        }
    }
}

// TypeTokenDemo.java —— Class<T> 类型令牌
import java.util.HashMap;
import java.util.Map;

public class TypeTokenDemo {
    // 调用方通过 Class<T> 告诉方法「我要什么类型」
    static <T> T fromMap(Map<String, Object> map, Class<T> clazz) throws Exception {
        T obj = clazz.getDeclaredConstructor().newInstance();
        // ... 反射回填字段（完整实现见 3.5 节 BeanMapConverter）
        return obj;
    }

    public static void main(String[] args) throws Exception {
        Map<String, Object> data = new HashMap<>();
        data.put("id", 1L);
        User user = fromMap(data, User.class);   // 类型令牌 User.class（User 来自第 2 章）
        System.out.println(user);
    }
}

// LambdaDemo.java —— 函数式接口与 Lambda 的四种写法
public class LambdaDemo {

    @FunctionalInterface
    interface Calculator {
        int calc(int a, int b);
    }

    public static void main(String[] args) {
        // 写法一：完整 Lambda（参数类型可省略）
        Calculator add = (int a, int b) -> a + b;
        // 写法二：省略参数类型
        Calculator sub = (a, b) -> a - b;
        // 写法三：方法体有多行时用大括号
        Calculator mul = (a, b) -> {
            System.out.println("乘法运算");
            return a * b;
        };
        // 写法四：方法引用（已有方法直接引用，最简洁）
        Calculator max = Math::max;

        System.out.println(add.calc(1, 2));   // 3
        System.out.println(sub.calc(5, 2));   // 3
        System.out.println(mul.calc(2, 3));   // 6
        System.out.println(max.calc(1, 2));   // 2
    }
}

// StreamDemo.java —— 三阶段与惰性验证
import java.util.List;

public class StreamDemo {
    public static void main(String[] args) {
        List<String> names = List.of("张三", "李四", "王五", "赵六");

        // 惰性验证：去掉终止操作，中间操作不会执行（下面这行没有任何输出）
        names.stream().filter(n -> {
            System.out.println("filter 执行了: " + n);
            return n.length() == 2;
        });

        System.out.println("---- 加上终止操作后 ----");

        // 加上终止操作 forEach，中间操作才会真正执行
        names.stream()
            .filter(n -> n.length() == 2)          // 中间：过滤
            .map(n -> "姓名:" + n)                 // 中间：转换
            .forEach(System.out::println);         // 终止：消费

        // 输出：
        // ---- 加上终止操作后 ----
        // 姓名:张三
        // 姓名:李四
        // 姓名:王五
        // 姓名:赵六
    }
}

// CollectDemo.java —— 常用终止操作：toList / toMap / groupingBy / 统计
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class CollectDemo {

    static class User {
        Long id; String name; Integer age;
        User(Long id, String name, Integer age) {
            this.id = id; this.name = name; this.age = age;
        }
        Long getId() { return id; }
        String getName() { return name; }
        Integer getAge() { return age; }
        @Override public String toString() { return "User{id=" + id + ", name='" + name + "', age=" + age + '}'; }
    }

    public static void main(String[] args) {
        List<User> users = List.of(
            new User(1L, "张三", 25),
            new User(2L, "李四", 30),
            new User(3L, "王五", 25),
            new User(4L, "赵六", 30)
        );

        // 1. filter + collect(toList)：过滤年龄 > 25
        List<User> adults = users.stream()
            .filter(u -> u.getAge() > 25)
            .collect(Collectors.toList());
        System.out.println("年龄>25: " + adults);

        // 2. map + collect(toList)：只取姓名
        List<String> names = users.stream()
            .map(User::getName)
            .collect(Collectors.toList());
        System.out.println("姓名列表: " + names);

        // 3. groupingBy：按年龄分组
        Map<Integer, List<User>> byAge = users.stream()
            .collect(Collectors.groupingBy(User::getAge));
        System.out.println("按年龄分组: " + byAge);

        // 4. 统计：数量、平均年龄、最大年龄
        long count = users.stream().count();
        double avgAge = users.stream().mapToInt(User::getAge).average().orElse(0);
        int maxAge = users.stream().mapToInt(User::getAge).max().orElse(0);
        System.out.println("人数=" + count + ", 平均年龄=" + avgAge + ", 最大年龄=" + maxAge);
    }
}

// ToMapDemo.java —— List 转 Map 的键重复问题
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class ToMapDemo {
    public static void main(String[] args) {
        List<CollectDemo.User> users = List.of(
            new CollectDemo.User(1L, "张三", 25),
            new CollectDemo.User(2L, "李四", 30),
            new CollectDemo.User(3L, "王五", 25)   // 年龄 25 出现两次
        );

        // 错误：按年龄做 key，会抛 IllegalStateException: Duplicate key
        // Map<Integer, CollectDemo.User> byAge = users.stream()
        //     .collect(Collectors.toMap(CollectDemo.User::getAge, Function.identity()));

        // 正确：用合并函数 (old, fresh) -> fresh，key 冲突时保留新值
        Map<Integer, CollectDemo.User> byAgeKeepNew = users.stream()
            .collect(Collectors.toMap(
                CollectDemo.User::getAge,
                Function.identity(),
                (oldValue, newValue) -> newValue       // 保留后出现的值
            ));
        System.out.println("保留新值: " + byAgeKeepNew);

        // 生产常用：按唯一 id 转 Map（id 唯一，合并函数只是防御性兜底）
        Map<Long, CollectDemo.User> byId = users.stream()
            .collect(Collectors.toMap(CollectDemo.User::getId, Function.identity(), (a, b) -> a));
        System.out.println("按 id 转 Map: " + byId);

        // 分组统计：每个年龄有多少人（groupingBy + counting）
        Map<Integer, Long> ageCount = users.stream()
            .collect(Collectors.groupingBy(CollectDemo.User::getAge, Collectors.counting()));
        System.out.println("各年龄人数: " + ageCount);
    }
}

// OptionalDemo.java —— Optional 的正确与错误用法
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public class OptionalDemo {

    static class UserService {
        // 模拟按 id 查询，可能查不到
        private static final Map<Long, String> DB = new HashMap<>();
        static { DB.put(1L, "张三"); }

        // 正确：返回 Optional<User>，显式表达「可能为空」
        Optional<String> findById(Long id) {
            return Optional.ofNullable(DB.get(id));
        }
    }

    public static void main(String[] args) {
        UserService service = new UserService();

        // 正确写法一：orElseThrow —— 查不到就抛业务异常（推荐，链式）
        String user = service.findById(1L)
            .orElseThrow(() -> new IllegalArgumentException("用户不存在"));
        System.out.println(user);

        // 正确写法二：orElse / orElseGet —— 给默认值
        String fallback = service.findById(999L).orElse("匿名用户");
        System.out.println(fallback);

        // 正确写法三：ifPresent —— 存在才执行
        service.findById(1L).ifPresent(u -> System.out.println("找到: " + u));

        // 正确写法四：map + filter 链式转换
        String upper = service.findById(1L)
            .map(String::toUpperCase)
            .filter(s -> s.length() > 1)
            .orElse("默认");
        System.out.println(upper);

        // 错误写法：isPresent + get（等价于判 null 再取值，失去 Optional 意义）
        // if (service.findById(1L).isPresent()) {
        //     String u = service.findById(1L).get();
        // }
    }
}

// ParallelDemo.java —— parallelStream 不是银弹（数据量小时串行更快）
import java.util.List;
import java.util.stream.IntStream;

public class ParallelDemo {
    public static void main(String[] args) {
        List<Integer> small = IntStream.rangeClosed(1, 1000).boxed().toList();
        List<Integer> large = IntStream.rangeClosed(1, 10_000_000).boxed().toList();

        // 数据量小：串行通常更快（并行有线程调度开销）
        long t1 = System.currentTimeMillis();
        long s1 = small.stream().mapToLong(Integer::longValue).sum();
        long t2 = System.currentTimeMillis();
        long s2 = small.parallelStream().mapToLong(Integer::longValue).sum();
        long t3 = System.currentTimeMillis();
        System.out.println("小数据 串行=" + (t2 - t1) + "ms, 并行=" + (t3 - t2) + "ms");

        // 数据量大：并行才有明显优势
        long t4 = System.currentTimeMillis();
        long l1 = large.stream().mapToLong(Integer::longValue).sum();
        long t5 = System.currentTimeMillis();
        long l2 = large.parallelStream().mapToLong(Integer::longValue).sum();
        long t6 = System.currentTimeMillis();
        System.out.println("大数据 串行=" + (t5 - t4) + "ms, 并行=" + (t6 - t5) + "ms");
    }
}

// FlatMapDemo.java —— flatMap 拍平嵌套集合
import java.util.List;
import java.util.stream.Collectors;

public class FlatMapDemo {
    public static void main(String[] args) {
        // 一个用户有多个订单号，需求：取出所有用户的全部订单号（去重）
        record UserOrders(String name, List<String> orders) {}
        List<UserOrders> list = List.of(
            new UserOrders("张三", List.of("O1", "O2")),
            new UserOrders("李四", List.of("O2", "O3"))
        );

        List<String> allOrders = list.stream()
            .flatMap(u -> u.orders().stream())   // 每个 UserOrders 展开成订单流，再拍平
            .distinct()                          // 去重 O2
            .collect(Collectors.toList());
        System.out.println(allOrders);           // [O1, O2, O3]
    }
}

// ReduceDemo.java —— reduce 归约
import java.util.List;

public class ReduceDemo {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5);
        int sum = nums.stream().reduce(0, Integer::sum);        // 求和 = 15
        int product = nums.stream().reduce(1, (a, b) -> a * b); // 求积 = 120
        System.out.println("sum=" + sum + ", product=" + product);
    }
}

// PartitionDemo.java —— partitionBy 二分 + summarizingInt 汇总
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class PartitionDemo {
    record Person(String name, int age) {}

    public static void main(String[] args) {
        List<Person> people = List.of(
            new Person("张三", 25), new Person("李四", 15),
            new Person("王五", 30), new Person("赵六", 10)
        );

        // partitionBy：按谓词二分（成年/未成年）
        Map<Boolean, List<Person>> adults = people.stream()
            .collect(Collectors.partitioningBy(p -> p.age() >= 18));
        System.out.println("成年人: " + adults.get(true));
        System.out.println("未成年: " + adults.get(false));

        // summarizingInt：一次拿到 count/sum/min/max/average
        var summary = people.stream().collect(Collectors.summarizingInt(Person::age));
        System.out.println("人数=" + summary.getCount()
            + ", 平均年龄=" + summary.getAverage()
            + ", 最大=" + summary.getMax());
    }
}

// OptionalFlatMapDemo.java —— flatMap 拍平嵌套 Optional
import java.util.Optional;

public class OptionalFlatMapDemo {
    public static void main(String[] args) {
        Optional<Optional<String>> nested = Optional.of(Optional.of("hello"));
        // map 会得到 Optional<Optional<String>>，flatMap 拍平成 Optional<String>
        String s = nested.flatMap(o -> o).orElse("空");
        System.out.println(s);
    }
}

// ErrorCode.java —— 统一错误码枚举（公共类，后续阶段逐字复用，基础码不得改动）
public enum ErrorCode {
    SUCCESS(0, "success"),
    PARAM_ERROR(40001, "参数错误"),
    UNAUTHORIZED(40101, "未登录或登录已过期"),
    FORBIDDEN(40301, "无权限访问"),
    USER_NOT_FOUND(40401, "用户不存在"),
    USER_EXISTS(40002, "用户名已存在"),
    SYSTEM_ERROR(50000, "系统繁忙，请稍后重试"),
    ;

    private final int code;
    private final String message;

    // 枚举构造器默认 private，无需显式写
    ErrorCode(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() { return code; }
    public String getMessage() { return message; }
}

// BizException.java —— 统一业务异常（公共类，后续阶段逐字复用）
public class BizException extends RuntimeException {

    private final int code;

    public BizException(ErrorCode ec) {
        super(ec.getMessage());   // 错误码里的 message 作为异常信息
        this.code = ec.getCode();
    }

    public BizException(int code, String message) {
        super(message);
        this.code = code;
    }

    public int getCode() { return code; }
}

// BizDemo.java —— 抛出与捕获业务异常
public class BizDemo {
    public static void main(String[] args) {
        try {
            registerUser("张三");
            registerUser("张三");   // 第二次触发「用户名已存在」
        } catch (BizException e) {
            // 打印业务码 + 业务提示，而不是堆栈
            System.out.println("业务失败: code=" + e.getCode() + ", msg=" + e.getMessage());
        }
    }

    static void registerUser(String name) {
        if ("张三".equals(name)) {
            // 抛业务异常：可预期的错误，用错误码表达
            throw new BizException(ErrorCode.USER_EXISTS);
        }
        System.out.println("注册成功: " + name);
    }
}

// BizException 追加构造器（在原有 (ErrorCode)/(int,String) 两个构造器基础上新增）
public BizException(int code, String message, Throwable cause) {
    super(message, cause);   // cause 挂到父类，getCause() 能拿到
    this.code = code;
}

// ExceptionChainDemo.java —— 异常链：包装底层异常并保留 cause
public class ExceptionChainDemo {
    public static void main(String[] args) {
        try {
            loadConfig();
        } catch (BizException e) {
            // getCause() 拿到被包装的原始异常，整条链定位根因
            System.out.println("业务异常: " + e.getMessage());
            System.out.println("根因: " + e.getCause());
        }
    }

    static void loadConfig() {
        try {
            // 模拟底层 IO 异常
            throw new java.io.IOException("配置文件不存在");
        } catch (java.io.IOException e) {
            // 包装成业务异常，同时用第三个参数保留原始异常链
            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "配置加载失败", e);
        }
    }
}

// TryWithResourcesDemo.java —— 自动关闭资源
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesDemo {
    public static void main(String[] args) {
        // 资源在 try 括号里声明，代码块结束后自动 close（倒序关闭）
        try (BufferedReader reader = new BufferedReader(new FileReader("pom.xml"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("读取失败: " + e.getMessage());
        }
    }
}

// JulDemo.java —— JDK 自带日志，零依赖即可运行（仅用于理解概念）
import java.util.logging.Logger;

public class JulDemo {
    private static final Logger log = Logger.getLogger(JulDemo.class.getName());

    public static void main(String[] args) {
        log.info("这是一条 info 日志");
        log.warning("这是一条 warning 日志");
    }
}

<!-- pom.xml —— 最小可运行配置，仅引入日志依赖（完整 Maven 讲解见第 7 章） -->
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>logging-demo</artifactId>
    <version>1.0.0</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- SLF4J 门面 API -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>2.0.13</version>
        </dependency>
        <!-- Logback 实现（会传递引入 slf4j-api，但显式声明更清晰） -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.5.6</version>
        </dependency>
    </dependencies>
</project>

<!-- src/main/resources/logback.xml —— Logback 基础配置 -->
<configuration>
    <!-- 控制台输出器 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 日志格式：时间 级别 线程名 类名 - 消息 -->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 根日志级别：INFO 及以上才输出（DEBUG 太多，生产默认 INFO） -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
    </root>

    <!-- 对指定包调级别：本包 DEBUG，方便排查时临时打开 -->
    <logger name="com.example" level="DEBUG"/>
</configuration>

// src/main/java/com/example/LogDemo.java —— 生产级日志写法
package com.example;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogDemo {

    // 每个类一个 Logger，参数传当前类，便于日志定位到具体类
    private static final Logger log = LoggerFactory.getLogger(LogDemo.class);

    public static void main(String[] args) {
        log.info("用户登录成功, userId={}", 10086);          // 占位符写法，避免字符串拼接开销
        log.debug("这是一条调试日志，生产默认不输出");

        try {
            int r = 1 / 0;
        } catch (Exception e) {
            // 异常必须带堆栈一起打（第二个参数传异常对象），否则丢失排查线索
            log.error("计算失败, userId={}", 10086, e);
        }
    }
}

mvn compile exec:java -Dexec.mainClass="com.example.LogDemo"
# 或先 mvn package 再 java -cp target/classes:$HOME/.m2/repository/... 运行