import java.util.*;

public class LambdaBasic {
    public static void main(String[] args) {
        // 传统写法：匿名内部类，5 行样板代码只为表达"比较两个字符串长度"
        Comparator<String> oldWay = new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return Integer.compare(a.length(), b.length());
            }
        };

        // Lambda：只保留参数列表与方法体，类型由编译器推断
        Comparator<String> newWay = (a, b) -> Integer.compare(a.length(), b.length());

        List<String> words = new ArrayList<>(List.of("java", "lambda", "go", "rust"));
        words.sort(newWay);           // go, java, rust, lambda
        System.out.println(words);
        words.forEach(w -> System.out.println(w.toUpperCase())); // 单参数可省略括号
    }
}

public class CaptureDemo {
    public static void main(String[] args) {
        int factor = 10;              // effectively final：从未被重新赋值
        // factor = 20;               // 取消注释会编译报错：变量必须是 final 或 effectively final
        Runnable r = () -> System.out.println(factor * 3);
        new Thread(r).start();

        // 实例字段与静态字段没有这个限制（它们存在堆里，本身就是共享的）
        Counter c = new Counter();
        Runnable inc = () -> c.value++;
        inc.run();
        System.out.println(c.value);  // 1
    }

    static class Counter { int value; }
}

import java.util.*;
import java.util.function.*;

public class MethodRefDemo {
    public static void main(String[] args) {
        // 1. 静态方法引用：(args) -> ClassName.staticMethod(args)
        Function<String, Integer> f1 = Integer::parseInt;

        // 2. 特定对象的实例方法引用：(args) -> instance.instanceMethod(args)
        List<String> box = new ArrayList<>();
        Consumer<String> f2 = box::add;

        // 3. 特定类型的任意对象实例方法引用：(a, rest) -> a.instanceMethod(rest)
        BiFunction<String, String, Boolean> f3 = String::startsWith; // (s, prefix) -> s.startsWith(prefix)

        // 4. 构造器引用：(args) -> new ClassName(args)
        Supplier<List<String>> f4 = ArrayList::new;
        Function<String, StringBuilder> f5 = StringBuilder::new;

        System.out.println(f1.apply("2048") + 1);   // 2049
        f2.accept("hello");
        System.out.println(f3.apply("hello", "he")); // true
        System.out.println(f4.get().size());         // 0
    }
}

public class ThisSemantics {
    private String name = "outer";

    void anonymous() {
        Runnable r = new Runnable() {
            private String name = "anonymous";
            @Override public void run() {
                System.out.println(this.name); // anonymous：this 指向匿名内部类实例
            }
        };
        r.run();
    }

    void lambda() {
        Runnable r = () -> System.out.println(this.name); // outer：this 指向 ThisSemantics 实例
        r.run();
    }

    public static void main(String[] args) {
        new ThisSemantics().anonymous(); // anonymous
        new ThisSemantics().lambda();    // outer
    }
}

import java.lang.invoke.*;
import java.util.function.*;

public class LambdaMetafactoryDemo {
    public static void main(String[] args) throws Throwable {
        // 手动模拟 JVM 为 Lambda 所做的事情：
        // 1. 找一个"调用点"，它的类型是函数式接口 IntBinaryOperator
        // 2. 实现方法是一个静态方法（Lambda 体被编译成私有静态方法 lambda$main$0）
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodType samType = MethodType.methodType(IntBinaryOperator.class);      // 工厂返回类型
        MethodType implType = MethodType.methodType(int.class, int.class, int.class); // 实现方法签名
        MethodHandle impl = lookup.findStatic(LambdaMetafactoryDemo.class,
                "lambda$main$0", implType);
        MethodType instantiatedType = MethodType.methodType(int.class, int.class, int.class);

        CallSite site = LambdaMetafactory.metafactory(
                lookup, "applyAsInt", samType, instantiatedType, impl, instantiatedType);
        IntBinaryOperator op = (IntBinaryOperator) site.getTarget().invoke();
        System.out.println(op.applyAsInt(6, 7)); // 42
    }

    // 编译器会把 Lambda 体编译成这样的私有静态方法（非捕获型）
    private static int lambda$main$0(int a, int b) {
        return a * b;
    }
}

import java.util.function.*;

public class FunctionPkgDemo {
    public static void main(String[] args) {
        Predicate<String> notEmpty = s -> s != null && !s.isEmpty();
        Function<String, Integer> toLen = String::length;
        UnaryOperator<Integer> square = x -> x * x;
        BinaryOperator<Integer> max = Integer::max;
        IntFunction<String> intToStr = i -> "编号" + i;   // 入参 int，避免 Integer 装箱
        BiFunction<Integer, Integer, String> fmt = (a, b) -> a + "/" + b;

        System.out.println(notEmpty.test("java"));   // true
        System.out.println(toLen.apply("java"));     // 4
        System.out.println(square.apply(9));         // 81
        System.out.println(max.apply(3, 7));         // 7
        System.out.println(intToStr.apply(17));      // 编号17
        System.out.println(fmt.apply(1, 2));         // 1/2
    }
}

import java.util.function.Function;

// 自定义：带受检异常的函数式接口（标准库没有，实际项目中很常见）
@FunctionalInterface
public interface CheckedFunction<T, R> {
    R apply(T t) throws Exception;

    // 默认方法不计入抽象方法数量，仍然合法
    default <V> CheckedFunction<T, V> andThen(CheckedFunction<R, V> after) {
        return t -> after.apply(apply(t));
    }

    // 静态方法：把受检异常转为运行时异常，方便在 Stream 中使用
    static <T, R> Function<T, R> unchecked(CheckedFunction<T, R> f) {
        return t -> {
            try {
                return f.apply(t);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        };
    }
}

import java.util.function.*;
import java.util.*;
import java.util.stream.*;

public class ComposeDemo {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = x -> x * 2;
        Function<Integer, Integer> plus1  = x -> x + 1;

        // andThen：先执行自己，再执行参数  -> plus1(times2(x))
        Function<Integer, Integer> f1 = times2.andThen(plus1);
        // compose：先执行参数，再执行自己  -> times2(plus1(x))
        Function<Integer, Integer> f2 = times2.compose(plus1);

        System.out.println(f1.apply(3)); // 7
        System.out.println(f2.apply(3)); // 8

        Predicate<String> startWithA = s -> s.startsWith("A");
        Predicate<String> lenGt3 = s -> s.length() > 3;
        List<String> data = List.of("Apple", "Ant", "Banana", "Ax");

        System.out.println(data.stream().filter(startWithA.and(lenGt3)).toList());   // [Apple]
        System.out.println(data.stream().filter(startWithA.or(lenGt3)).toList());    // [Apple, Banana]
        System.out.println(data.stream().filter(startWithA.negate()).toList());      // [Banana]

        // Consumer 也有 andThen，常用于"先打印再落库"这类流水线
        Consumer<String> log = s -> System.out.println("[log] " + s);
        Consumer<String> save = s -> System.out.println("[db ] " + s);
        data.forEach(log.andThen(save));
    }
}

import java.util.*;
import java.util.stream.*;
import java.math.BigDecimal;

// 需求：从订单列表中找出"金额大于 1000 且状态为已支付"的订单，按金额降序取前 3 个订单号
class Order {
    private final String id;
    private final BigDecimal amount;
    private final String status;

    Order(String id, String amount, String status) {
        this.id = id; this.amount = new BigDecimal(amount); this.status = status;
    }

    public String getId() { return id; }
    public BigDecimal getAmount() { return amount; }
    public String getStatus() { return status; }
}

public class RefactorDemo {
    // 改造前：21 行命令式代码，5 个临时变量，阅读时要在脑子里维护一个状态机
    static List<String> before(List<Order> orders) {
        List<Order> filtered = new ArrayList<>();
        for (Order o : orders) {
            if (o.amount.compareTo(new BigDecimal("1000")) > 0 && "PAID".equals(o.status)) {
                filtered.add(o);
            }
        }
        filtered.sort(new Comparator<Order>() {
            @Override public int compare(Order a, Order b) {
                return b.amount.compareTo(a.amount);
            }
        });
        List<String> ids = new ArrayList<>();
        int n = Math.min(3, filtered.size());
        for (int i = 0; i < n; i++) {
            ids.add(filtered.get(i).id);
        }
        return ids;
    }

    // 改造后：声明式，每一步读起来就是一句需求描述
    static List<String> after(List<Order> orders) {
        return orders.stream()
                .filter(o -> o.amount.compareTo(new BigDecimal("1000")) > 0)
                .filter(o -> "PAID".equals(o.status))
                .sorted(Comparator.comparing(Order::getAmount).reversed())
                .limit(3)
                .map(Order::getId)
                .toList();   // JDK 16+
    }

    public static void main(String[] args) {
        List<Order> orders = List.of(
                new Order("A01", "1200", "PAID"),
                new Order("A02", "800", "PAID"),
                new Order("A03", "3000", "PAID"),
                new Order("A04", "5000", "UNPAID"),
                new Order("A05", "2000", "PAID"));
        System.out.println(before(orders));  // [A03, A05, A01]
        System.out.println(after(orders));   // [A03, A05, A01]
    }
}

import java.util.stream.*;
import java.util.*;

public class StreamOnceDemo {
    public static void main(String[] args) {
        Stream<String> s = Stream.of("a", "b", "c");
        System.out.println(s.count());  // 3
        try {
            s.forEach(System.out::println); // 抛 IllegalStateException: stream has already been operated upon or closed
        } catch (IllegalStateException e) {
            System.out.println("错误：" + e.getMessage());
        }
        // 正确做法：需要多次遍历就重新创建流，或用 Supplier<Stream<T>> 包装
        Supplier<Stream<String>> supplier = () -> Stream.of("a", "b", "c");
        System.out.println(supplier.get().count());
        supplier.get().forEach(System.out::println);
    }
}

import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.stream.*;
import java.math.BigInteger;

public class CreateStreamDemo {
    public static void main(String[] args) throws IOException {
        // 1. 集合：Collection.stream() / parallelStream()
        Stream<String> s1 = List.of("a", "b").stream();

        // 2. 数组：Arrays.stream() 或 Stream.of()
        IntStream s2 = Arrays.stream(new int[]{1, 2, 3});
        Stream<Integer> s2b = Arrays.stream(new Integer[]{1, 2, 3}); // 注意不是 IntStream

        // 3. Stream.of / Stream.ofNullable（JDK 9+，null 变空流，避免 NPE）
        Stream<String> s3 = Stream.of("x", "y");
        Stream<String> s3b = Stream.ofNullable(null); // 空流

        // 4. 生成器：iterate（有种子，按顺序推导）/ generate（无状态，无限）
        Stream<Integer> s4 = Stream.iterate(1, n -> n * 2).limit(5); // 1,2,4,8,16
        Stream<BigInteger> fib = Stream.iterate(new BigInteger[]{BigInteger.ZERO, BigInteger.ONE},
                a -> new BigInteger[]{a[1], a[0].add(a[1])})
                .map(a -> a[0]).limit(10);
        Stream<Double> randoms = Stream.generate(Math::random).limit(3);

        // 5. 文件：Files.lines（按行，需关闭）/ BufferedReader.lines()
        try (Stream<String> lines = Files.lines(Path.of("pom.xml"))) {
            long n = lines.filter(l -> l.contains("java")).count();
            System.out.println("包含 java 的行数：" + n);
        }

        // 6. 基本类型流与 range：IntStream.range 不含上界，rangeClosed 含上界
        int sum = IntStream.rangeClosed(1, 100).sum(); // 5050
        System.out.println(s4.toList() + " " + fib.toList());
        System.out.println(randoms.toList().size() + " " + sum);
    }
}

import java.util.stream.*;
import java.util.*;

public class LazyDemo {
    public static void main(String[] args) {
        System.out.println("=== 没有终端操作，中间操作一行都不执行 ===");
        Stream.of("a1", "a2", "b1", "c2", "c1")
                .filter(s -> { System.out.println("filter: " + s); return s.startsWith("a"); });
        // 上面这行运行后没有任何输出！因为没有终端操作

        System.out.println("=== 加上终端操作后，元素逐个穿过流水线 ===");
        Stream.of("a1", "a2", "b1", "c2", "c1")
                .filter(s -> { System.out.println("filter: " + s); return s.startsWith("c"); })
                .map(s -> { System.out.println("map: " + s); return s.toUpperCase(); })
                .forEach(s -> System.out.println("forEach: " + s));
        // 输出顺序：filter b1 / filter c2 / map c2 / forEach C2 ...
        // 注意是"纵向"执行：一个元素走完全部操作，再处理下一个元素

        System.out.println("=== 短路优化：limit(2) 让流水线提前结束 ===");
        Stream.of("a1", "a2", "a3", "a4")
                .peek(s -> System.out.println("peek: " + s))
                .limit(2)
                .toList();
        // 只输出 peek: a1 / peek: a2，a3 a4 根本没被处理
    }
}

import java.util.*;
import java.util.stream.*;
import java.math.BigDecimal;

// Record 作为 DTO：自动获得构造器、访问器、equals/hashCode/toString
record Order(String id, String category, BigDecimal amount, String status) {}

public class CollectorsDemo {
    public static void main(String[] args) {
        List<Order> orders = List.of(
                new Order("1", "数码", new BigDecimal("2999"), "PAID"),
                new Order("2", "数码", new BigDecimal("899"), "PAID"),
                new Order("3", "图书", new BigDecimal("59"), "PAID"),
                new Order("4", "图书", new BigDecimal("129"), "UNPAID"),
                new Order("5", "服饰", new BigDecimal("399"), "PAID"),
                new Order("6", "数码", new BigDecimal("5999"), "PAID"));

        // 1. toList / toSet / toCollection：JDK 16 的 toList 返回不可变 List
        List<String> ids = orders.stream().map(Order::id).toList();
        Set<String> cats = orders.stream().map(Order::category).collect(Collectors.toSet());
        LinkedList<String> linked = orders.stream().map(Order::id)
                .collect(Collectors.toCollection(LinkedList::new));

        // 2. joining：拼接字符串，可带分隔符、前缀、后缀
        String joined = orders.stream().map(Order::id).collect(Collectors.joining(", ", "[", "]"));
        System.out.println(joined); // [1, 2, 3, 4, 5, 6]

        // 3. toMap：注意键冲突！第三个参数是 merge 函数
        Map<String, Order> byId = orders.stream()
                .collect(Collectors.toMap(Order::id, o -> o, (a, b) -> a)); // 冲突时保留前者

        // 4. groupingBy：一级分组
        Map<String, List<Order>> byCat = orders.stream()
                .collect(Collectors.groupingBy(Order::category));

        // 5. groupingBy + 下游收集器：分组后统计（分组计数、分组求和）
        Map<String, Long> countByCat = orders.stream()
                .collect(Collectors.groupingBy(Order::category, Collectors.counting()));
        Map<String, BigDecimal> sumByCat = orders.stream()
                .collect(Collectors.groupingBy(Order::category,
                        Collectors.reducing(BigDecimal.ZERO, Order::amount, BigDecimal::add)));

        // 6. groupingBy + summarizingXXX：一次拿到 count/sum/min/max/average
        Map<String, IntSummaryStatistics> statByCat = orders.stream()
                .collect(Collectors.groupingBy(Order::category,
                        Collectors.summarizingInt(o -> o.amount.intValue())));
        System.out.println("数码: " + statByCat.get("数码"));

        // 7. 多级分组：先按状态再按品类
        Map<String, Map<String, List<Order>>> multi = orders.stream()
                .collect(Collectors.groupingBy(Order::status,
                        Collectors.groupingBy(Order::category)));

        // 8. partitioningBy：按布尔条件二分，key 只有 true/false
        Map<Boolean, List<Order>> paidPartition = orders.stream()
                .collect(Collectors.partitioningBy(o -> "PAID".equals(o.status)));

        // 9. 分组后取每组金额最高的订单（下游用 collectingAndThen + maxBy）
        Map<String, Optional<Order>> topByCat = orders.stream()
                .collect(Collectors.groupingBy(Order::category,
                        Collectors.maxBy(Comparator.comparing(Order::amount))));
        System.out.println(topByCat);
    }
}

import java.util.*;
import java.util.stream.*;

public class CustomCollectorDemo {
    // 需求：把字符串流收集为一个"不可变且已排序"的 List
    static <T extends Comparable<? super T>> Collector<T, ?, List<T>> toSortedImmutableList() {
        return Collector.of(
                ArrayList::new,                      // supplier：可变容器
                List::add,                           // accumulator：累加
                (left, right) -> { left.addAll(right); return left; }, // combiner：并行合并
                list -> { list.sort(null); return Collections.unmodifiableList(list); }, // finisher
                Collector.Characteristics.UNORDERED  // 声明不关心顺序，允许框架优化
        );
    }

    public static void main(String[] args) {
        List<String> result = Stream.of("pear", "apple", "orange", "banana")
                .collect(toSortedImmutableList());
        System.out.println(result); // [apple, banana, orange, pear]
        // result.add("x"); // 抛 UnsupportedOperationException
    }
}

import java.util.*;
import java.util.stream.*;

public class FlatMapDemo {
    public static void main(String[] args) {
        List<List<String>> nested = List.of(
                List.of("Java", "Kotlin"),
                List.of("Python", "Go"),
                List.of("Rust"));

        // map：得到 Stream<List<String>>，还要再处理一层，很别扭
        List<List<String>> wrong = nested.stream().map(l -> l).toList();

        // flatMap：直接摊平成 Stream<String>
        List<String> flat = nested.stream().flatMap(Collection::stream).toList();
        System.out.println(flat); // [Java, Kotlin, Python, Go, Rust]

        // 实战：句子列表 -> 去重后的单词列表
        List<String> sentences = List.of("Hello world", "Hello java", "java stream");
        List<String> words = sentences.stream()
                .flatMap(s -> Arrays.stream(s.toLowerCase().split(" ")))
                .distinct()
                .sorted()
                .toList();
        System.out.println(words); // [hello, java, stream, world]

        // 实战：笛卡尔积（两个集合的所有组合）
        List<String> colors = List.of("红", "蓝");
        List<String> sizes = List.of("S", "L");
        List<String> product = colors.stream()
                .flatMap(c -> sizes.stream().map(s -> c + "-" + s))
                .toList();
        System.out.println(product); // [红-S, 红-L, 蓝-S, 蓝-L]

        // 基本类型流的 flatMap：IntStream.flatMap 返回 IntStream，避免装箱
        int[] boxed = IntStream.of(1, 2).flatMap(i -> IntStream.range(0, i)).toArray();
        System.out.println(Arrays.toString(boxed)); // [0, 0, 1]
    }
}

import java.util.*;
import java.util.stream.*;
import java.util.concurrent.*;

public class StreamPitfallDemo {
    public static void main(String[] args) throws Exception {
        // 坑 1：复用已消费的流（见 4.1）

        // 坑 2：toMap 键冲突抛 IllegalStateException
        List<String> dup = List.of("a", "a", "b");
        try {
            dup.stream().collect(Collectors.toMap(s -> s, String::length)); // 抛异常
        } catch (IllegalStateException e) {
            System.out.println("坑2：" + e.getMessage()); // Duplicate key a
        }
        Map<String, Integer> ok = dup.stream()
                .collect(Collectors.toMap(s -> s, String::length, Integer::sum)); // 用 merge 函数

        // 坑 3：基本类型流的装箱开销
        // 慢：Stream<Integer> 每次运算都要装箱
        long boxedSum = IntStream.range(0, 10_000_000).boxed().mapToLong(i -> i).sum();
        // 快：全程 IntStream/LongStream
        long rawSum = LongStream.range(0, 10_000_000).sum();
        System.out.println("坑3：" + boxedSum + " " + rawSum);

        // 坑 4：parallelStream 默认使用公共 ForkJoinPool，会被阻塞任务污染
        // 下面的代码会让整个 JVM 里所有 parallelStream 都变慢（commonPool 只有 CPU 核心数-1 个线程）
        // List.of("a","b").parallelStream().forEach(s -> { Thread.sleep(5000); });

        // 正确做法：I/O 密集型并行任务放到自定义线程池中执行（必须在 pool 内提交才生效）
        ForkJoinPool custom = new ForkJoinPool(4);
        custom.submit(() ->
                IntStream.range(0, 10).parallel().forEach(i -> System.out.print(i + " "))
        ).get();
        custom.shutdown();

        // 坑 5：forEach 在并行流下不保证顺序，需要顺序用 forEachOrdered
        IntStream.range(0, 10).parallel().forEach(i -> System.out.print(i + " "));       // 乱序
        System.out.println();
        IntStream.range(0, 10).parallel().forEachOrdered(i -> System.out.print(i + " ")); // 0..9
        System.out.println();

        // 坑 6：sorted 会把所有元素缓冲到内存，无限流上用 sorted 会 OOM
        // 坑 7：Optional.get() 前不判断，抛 NoSuchElementException
        System.out.println("坑2修复：" + ok);
    }
}

import java.util.*;

public class OptionalBasic {
    // 反模式：字段用 Optional（不可序列化、增加内存开销、语义无收益）
    // static class Bad { Optional<String> name; }

    // 正确：方法返回值用 Optional
    static Optional<String> findNameById(int id) {
        return id > 0 ? Optional.of("user" + id) : Optional.empty();
    }

    public static void main(String[] args) {
        Optional<String> a = Optional.of("java");        // 明确非空，传 null 立刻 NPE（快速失败）
        Optional<String> b = Optional.ofNullable(null);  // 可能为 null
        Optional<String> c = Optional.empty();           // 明确为空

        // 反模式：isPresent + get 等价于传统的 if (x != null)，没有任何收益
        if (a.isPresent()) {
            System.out.println(a.get().toUpperCase());
        }

        // 正模式：函数式消费
        a.ifPresent(s -> System.out.println(s.toUpperCase()));
        a.ifPresentOrElse(s -> System.out.println("有值：" + s),
                          () -> System.out.println("无值"));  // JDK 9+
    }
}

import java.util.*;

public class OrElseDemo {
    static String defaultValue() {
        System.out.println("  >> defaultValue() 被调用了");
        return "默认值";
    }

    public static void main(String[] args) {
        Optional<String> present = Optional.of("真实值");
        Optional<String> empty = Optional.empty();

        System.out.println("1) orElse（有值时）：");
        System.out.println("  结果 = " + present.orElse(defaultValue()));
        // 关键点：即使 Optional 有值，defaultValue() 依然会被执行！参数先求值再传参。

        System.out.println("2) orElseGet（有值时）：");
        System.out.println("  结果 = " + present.orElseGet(OrElseDemo::defaultValue));
        // Supplier 懒执行，有值时根本不调用

        System.out.println("3) orElseGet（空值时）：");
        System.out.println("  结果 = " + empty.orElseGet(OrElseDemo::defaultValue));

        System.out.println("4) orElseThrow（空值时抛自定义异常）：");
        try {
            empty.orElseThrow(() -> new IllegalStateException("用户不存在"));
        } catch (IllegalStateException e) {
            System.out.println("  捕获：" + e.getMessage());
        }
        System.out.println("5) orElseThrow() 无参版（JDK 10+，抛 NoSuchElementException）：");
        System.out.println("  " + present.orElseThrow());
    }
}

import java.util.*;
import java.util.stream.*;

public class OptionalChain {
    static Optional<String> getCity() { return Optional.of("  HangZhou  "); }
    static Optional<Integer> parse(String s) {
        try { return Optional.of(Integer.parseInt(s)); }
        catch (NumberFormatException e) { return Optional.empty(); }
    }

    public static void main(String[] args) {
        // 链式：去空白 -> 过滤非空 -> 转大写 -> 兜底
        String city = getCity()
                .map(String::strip)          // JDK 11 的 strip，比 trim 更彻底（支持 Unicode 空白）
                .filter(s -> !s.isEmpty())
                .map(String::toUpperCase)
                .orElse("UNKNOWN");
        System.out.println(city); // HANGZHOU

        // flatMap：避免嵌套 Optional
        Optional<Integer> nested = getCity().flatMap(OptionalChain::parse);

        // stream()：把 Optional 无缝接入 Stream 管道（JDK 9+）
        List<Optional<String>> list = List.of(Optional.of("a"), Optional.empty(), Optional.of("b"));
        List<String> flat = list.stream().flatMap(Optional::stream).toList();
        System.out.println(flat); // [a, b]

        // or()：JDK 9+ 的备用 Optional 链
        String v = Optional.<String>empty()
                .or(() -> Optional.of("第二备选"))
                .orElse("最终兜底");
        System.out.println(v); // 第二备选
    }
}

// MyBatis Mapper：直接返回 Optional，MyBatis 3.5+ 支持 Optional 返回类型
public interface UserMapper {
    Optional<User> findById(Long id);      // 查不到自动变 Optional.empty()
    List<User> findByStatus(String status); // 集合查询不要返回 Optional<List>，返回空集合即可
}

// JPA Repository 同理
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

// Service 层：用 orElseThrow 把"查不到"翻译成业务异常
class UserService {
    private final UserMapper mapper;
    UserService(UserMapper mapper) { this.mapper = mapper; }

    User requireUser(Long id) {
        return mapper.findById(id)
                .orElseThrow(() -> new IllegalArgumentException("用户不存在, id=" + id));
    }
    static class User {}
}

import java.util.*;

public class FactoryMethodDemo {
    public static void main(String[] args) {
        // JDK 9+：一行创建不可变集合（底层是 ImmutableCollections，比 Collections.unmodifiableList 更省内存）
        List<String> list = List.of("a", "b", "c");
        Set<Integer> set = Set.of(1, 2, 3);          // 重复元素抛 IllegalArgumentException
        Map<String, Integer> map = Map.of("a", 1, "b", 2);              // 最多 10 对
        Map<String, Integer> map2 = Map.ofEntries(Map.entry("a", 1), Map.entry("b", 2)); // 任意数量

        // 注意：of() 不接受 null 元素（存 null 会 NPE），这是刻意设计
        // 需要可变集合就包一层
        List<String> mutable = new ArrayList<>(List.of("a", "b"));

        // JDK 10+：List.copyOf / Set.copyOf / Map.copyOf 做防御性拷贝
        List<String> copy = List.copyOf(mutable);
        System.out.println(list + " " + set + " " + map + " " + copy);
    }
}

import java.util.*;
import java.util.stream.*;

public class Jdk9StreamDemo {
    public static void main(String[] args) {
        // takeWhile：从头取，遇到第一个不满足的元素就停（有序流上才短路）
        System.out.println(Stream.of(1, 2, 3, 4, 1, 2).takeWhile(i -> i < 4).toList()); // [1, 2, 3]
        // dropWhile：从头丢弃，遇到第一个不满足的就开始保留
        System.out.println(Stream.of(1, 2, 3, 4, 1, 2).dropWhile(i -> i < 4).toList()); // [4, 1, 2]
        // iterate 三参版：带终止条件的 iterate（JDK 9+），替代了 limit 的老写法
        System.out.println(Stream.iterate(1, i -> i < 20, i -> i * 2).toList()); // [1,2,4,8,16]
        // ofNullable：null 变空流，在 map 之后特别有用
        System.out.println(Stream.ofNullable(null).count()); // 0

        String s = "  Hello\nJava\r\n  \n";
        System.out.println(s.isBlank());                 // false（有非空白字符）
        System.out.println(s.strip());                   // 去首尾 Unicode 空白（比 trim 强）
        System.out.println(s.stripLeading());
        System.out.println(s.lines().toList());          // 按行切分为 Stream<String>
        System.out.println("ab".repeat(3));              // ababab
        System.out.println("   ".isBlank());             // true
    }
}

import java.util.*;

public class VarDemo {
    public static void main(String[] args) {
        var name = "java";           // 推断为 String
        var list = new ArrayList<String>(); // 推断为 ArrayList<String>
        try (var reader = new java.io.BufferedReader(new java.io.StringReader("hi"))) {
            System.out.println(reader.readLine());
        } catch (Exception e) { /* 忽略 */ }
        for (var s : List.of("a", "b")) {
            System.out.println(s.toUpperCase());
        }

        // 以下都是非法的：
        // var x;                    // 必须初始化
        // var n = null;             // 无法推断
        // var fn = (a, b) -> a + b; // Lambda 不能作为 var 的目标（无法推断函数式接口类型）
        // var field = 1;            // 不能用于字段
        // var m(String a) {}        // 不能用于方法参数与返回类型
    }
}

import java.net.URI;
import java.net.http.*;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;

public class HttpClientDemo {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)           // 优先 HTTP/2
                .connectTimeout(Duration.ofSeconds(5))
                .followRedirects(HttpClient.Redirect.NORMAL)
                .build();

        // 1. 同步 GET
        HttpRequest get = HttpRequest.newBuilder()
                .uri(URI.create("https://httpbin.org/get"))
                .timeout(Duration.ofSeconds(10))
                .header("Accept", "application/json")
                .GET()
                .build();
        HttpResponse<String> resp = client.send(get, HttpResponse.BodyHandlers.ofString());
        System.out.println("状态码：" + resp.statusCode());
        System.out.println("响应体：" + resp.body());

        // 2. 异步 GET：返回 CompletableFuture，不阻塞当前线程
        CompletableFuture<HttpResponse<String>> future =
                client.sendAsync(get, HttpResponse.BodyHandlers.ofString());
        future.thenApply(HttpResponse::body)
              .thenAccept(b -> System.out.println("异步长度：" + b.length()))
              .join(); // 示例中为等待结果，生产环境不要 join

        // 3. POST JSON
        HttpRequest post = HttpRequest.newBuilder()
                .uri(URI.create("https://httpbin.org/post"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"java\"}"))
                .build();
        System.out.println(client.send(post, HttpResponse.BodyHandlers.ofString()).statusCode());

        // 4. 直接把响应体保存为文件（流式，不占内存）
        // client.send(get, HttpResponse.BodyHandlers.ofFile(Path.of("out.json")));
    }
}

public class SwitchExprDemo {
    // 旧写法：break 满天飞，还要一个临时变量承接结果
    static int oldDaysInMonth(int month, int year) {
        int days;
        switch (month) {
            case 1: case 3: case 5: case 7: case 8: case 10: case 12:
                days = 31; break;
            case 4: case 6: case 9: case 11:
                days = 30; break;
            case 2:
                days = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ? 29 : 28;
                break;
            default:
                throw new IllegalArgumentException("非法月份: " + month);
        }
        return days;
    }

    // 新写法：箭头语法、多值逗号分隔、不需要 break、可直接作为表达式赋值
    static int newDaysInMonth(int month, int year) {
        return switch (month) {
            case 1, 3, 5, 7, 8, 10, 12 -> 31;
            case 4, 6, 9, 11           -> 30;
            case 2 -> (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ? 29 : 28;
            default -> throw new IllegalArgumentException("非法月份: " + month);
        };
    }

    // 需要多语句时用代码块 + yield 返回值
    static String describe(int score) {
        return switch (score / 10) {
            case 10, 9 -> "优秀";
            case 8, 7  -> "良好";
            case 6     -> {
                System.out.println("及格线边缘");
                yield "及格"; // yield 只在 switch 表达式的代码块中使用
            }
            default -> "不及格";
        };
    }

    public static void main(String[] args) {
        System.out.println(newDaysInMonth(2, 2024));  // 29
        System.out.println(describe(65));             // 及格
    }
}

public class TextBlockDemo {
    public static void main(String[] args) {
        // 传统写法：一堆 \n 和 + 号，缩进全乱
        String oldJson = "{\n" +
                         "  \"name\": \"java\",\n" +
                         "  \"version\": 21\n" +
                         "}";

        // 文本块：所见即所得
        String json = """
                {
                  "name": "java",
                  "version": 21,
                  "features": ["record", "sealed", "virtual-thread"]
                }
                """;

        String sql = """
                SELECT u.id, u.name, COUNT(o.id) AS cnt
                  FROM t_user u
                  LEFT JOIN t_order o ON o.user_id = u.id
                 WHERE u.status = 1
                 GROUP BY u.id, u.name
                 ORDER BY cnt DESC
                """;

        // \s 转义：保留行尾空格（默认行尾空白会被裁掉），常用于需要精确控制的场景
        String withTrailingSpace = """
                line1\s
                line2
                """;

        // formatted()：JDK 15 起文本块直接支持格式化，无需 String.format
        String tpl = """
                <h1>%s</h1>
                <p>共 %d 条记录</p>
                """.formatted("报表", 42);

        System.out.println(json);
        System.out.println(sql.split("\n")[0]);
        System.out.println(tpl);
    }
}

import java.util.*;

public class InstanceofPatternDemo {
    // 旧写法：强转三次，变量作用域外泄
    static String oldWay(Object o) {
        if (o instanceof String) {
            String s = (String) o;      // 手动强转
            if (s.length() > 5) {
                return "长字符串：" + s.toUpperCase();
            }
            return "短字符串：" + s;
        }
        return "非字符串";
    }

    // 新写法：类型模式——判断与绑定一步完成，绑定变量作用域精确（仅在 && 右侧可用的流作用域规则）
    static String newWay(Object o) {
        if (o instanceof String s && s.length() > 5) {
            return "长字符串：" + s.toUpperCase(); // s 已绑定，直接可用
        }
        if (o instanceof String s) {
            return "短字符串：" + s;
        }
        if (!(o instanceof Integer i)) {
            return "非整数";
        }
        return "整数：" + (i * 2); // i 在这里依然可用（因为上面已经 return）
    }

    // 结合 equals 的常见写法
    static boolean safeEquals(Object a, Object b) {
        return (a instanceof String sa) && (b instanceof String sb) && sa.equals(sb);
    }

    public static void main(String[] args) {
        System.out.println(newWay("hello world"));  // 长字符串：HELLO WORLD
        System.out.println(newWay(21));             // 整数：42
    }
}

import java.util.*;

// 一行顶五十行：自动生成字段、构造器、访问器、equals/hashCode/toString
public record Point(int x, int y) {
    // 紧凑构造器（compact constructor）：省略参数列表与赋值，只做校验与规范化
    public Point {
        if (x < 0 || y < 0) {
            throw new IllegalArgumentException("坐标不能为负: " + x + "," + y);
        }
    }

    // 可以添加实例方法、静态方法、额外的构造器，但不能添加实例字段（静态字段可以）
    public double distanceTo(Point other) {
        return Math.hypot(x - other.x, y - other.y);
    }

    public static Point origin() { return new Point(0, 0); }
}

class RecordUsage {
    public static void main(String[] args) {
        Point p = new Point(3, 4);
        System.out.println(p.x());           // 3 —— 访问器就是方法名本身，没有 get 前缀
        System.out.println(p);               // Point[x=3, y=4] —— 自动生成的 toString
        System.out.println(p.equals(new Point(3, 4))); // true —— 按组件逐个比较

        // 反编译可见：Point 是 final 类，继承 java.lang.Record，
        // 字段是 private final，方法带 @Override 且被标记为 record 组件方法
        System.out.println(Point.class.isRecord());        // true
        System.out.println(Arrays.toString(Point.class.getRecordComponents()));
        try {
            new Point(-1, 2);
        } catch (IllegalArgumentException e) {
            System.out.println("校验生效：" + e.getMessage());
        }
    }
}

// sealed：限制子类；permits 明确列出允许的子类（同包或同模块时 permits 可省略，编译器自动推断）
public sealed interface Shape
        permits Circle, Rectangle, Triangle {   // 三个子类必须在同一包/同一模块
    double area();
}

final class Circle implements Shape {
    private final double radius;
    Circle(double radius) { this.radius = radius; }
    public double area() { return Math.PI * radius * radius; }
}

// sealed 子类：继续向下限制
sealed class Rectangle implements Shape permits Square {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }
    public double area() { return w * h; }
}

// non-sealed 子类：重新开放继承（打破密封链）
non-sealed class Triangle implements Shape {
    public double area() { return 42; }
}

final class Square extends Rectangle {
    Square(double side) { super(side, side); }
}

public class HelpfulNpeDemo {
    record User(String name, Address addr) {}
    record Address(String city) {}

    public static void main(String[] args) {
        User u = new User("tom", null);
        // JDK 14+ 的异常信息：
        // Cannot invoke "Address.city()" because "u.addr()" is null
        System.out.println(u.addr().city());
    }
}

import java.util.*;

public class PatternSwitchDemo {
    sealed interface Expr permits NumExpr, AddExpr, MulExpr, NegExpr {}
    record NumExpr(int value) implements Expr {}
    record AddExpr(Expr left, Expr right) implements Expr {}
    record MulExpr(Expr left, Expr right) implements Expr {}
    record NegExpr(Expr inner) implements Expr {}

    // 传统写法：一堆 instanceof + 强转
    static int evalOld(Expr e) {
        if (e instanceof NumExpr) return ((NumExpr) e).value();
        if (e instanceof AddExpr) return evalOld(((AddExpr) e).left()) + evalOld(((AddExpr) e).right());
        if (e instanceof MulExpr) return evalOld(((MulExpr) e).left()) * evalOld(((MulExpr) e).right());
        if (e instanceof NegExpr) return -evalOld(((NegExpr) e).inner());
        throw new IllegalArgumentException();
    }

    // switch 模式匹配 + 记录解构模式：一行一个分支，结构一目了然
    static int eval(Expr e) {
        return switch (e) {
            case NumExpr(int v)        -> v;                       // 解构出 value
            case AddExpr(var l, var r) -> eval(l) + eval(r);       // 嵌套解构
            case MulExpr(var l, var r) -> eval(l) * eval(r);
            case NegExpr(var i)        -> -eval(i);
            // 密封接口已穷举所有子类型，编译器知道无需 default
        };
    }

    // 守卫 when：在类型模式上附加条件
    static String classify(Object o) {
        return switch (o) {
            case Integer i when i > 100 -> "大整数 " + i;
            case Integer i              -> "小整数 " + i;
            case String s when s.isBlank() -> "空串";
            case String s               -> "字符串 " + s.length();
            case null                   -> "null 值";   // JDK 21 支持显式 null 分支
            default                     -> "其它";
        };
    }

    public static void main(String[] args) {
        Expr expr = new AddExpr(new NumExpr(2), new MulExpr(new NumExpr(3), new NumExpr(4)));
        System.out.println(eval(expr)); // 14
        System.out.println(classify(200)); // 大整数 200
    }
}

import java.util.concurrent.*;

public class VirtualThreadQuickLook {
    public static void main(String[] args) throws Exception {
        // 三种创建方式
        Thread v1 = Thread.ofVirtual().name("vt-1").start(() -> System.out.println("方式1"));
        Thread v2 = Thread.startVirtualThread(() -> System.out.println("方式2"));
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            executor.submit(() -> System.out.println("方式3")).get();
        }
        v1.join(); v2.join();

        // 对比：创建 10 万个虚拟线程 vs 平台线程
        long start = System.currentTimeMillis();
        try (var exec = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 100_000; i++) {
                exec.submit(() -> { Thread.sleep(10); return null; });
            }
        } // 关闭时等待全部完成
        System.out.println("10 万虚拟线程耗时：" + (System.currentTimeMillis() - start) + "ms");
    }
}

import java.util.*;

public class SequencedDemo {
    public static void main(String[] args) {
        // 过去取 LinkedHashSet 的最后一个元素要转成迭代器或 ArrayList，现在一行搞定
        SequencedSet<String> set = new LinkedHashSet<>(List.of("a", "b", "c"));
        System.out.println(set.getFirst() + " / " + set.getLast()); // a / c
        System.out.println(set.reversed());                          // [c, b, a]

        SequencedMap<String, Integer> map = new LinkedHashMap<>();
        map.put("one", 1); map.put("two", 2);
        System.out.println(map.firstEntry() + " " + map.lastEntry()); // one=1 two=2
        System.out.println(map.pollLastEntry());                      // two=2，并移除
        System.out.println(map);                                      // {one=1}
    }
}