Lambda表达式 ⭐

// 匿名内部类写法 —— 冗长、仪式感重
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.compareTo(b); // 实际有用的只有这一行
    }
});

// Lambda 写法 —— 简洁、意图清晰
Collections.sort(names, (a, b) -> a.compareTo(b));

// 完整写法：显式声明参数类型，方法体用花括号包裹，显式 return
(String a, String b) -> {
    return a.compareTo(b); // 显式指定参数类型为 String
}

// 省略参数类型：编译器根据上下文自动推断 a 和 b 的类型
(a, b) -> {
    return a.compareTo(b); // 编译器知道这是 Comparator<String>，所以 a、b 是 String
}

// 单表达式：省略花括号和 return，表达式的值自动作为返回值
(a, b) -> a.compareTo(b)

// 单参数：可以省略圆括号
name -> name.toUpperCase() // 只有一个参数时，括号可以省略

// 无参数：必须保留空的圆括号
() -> System.out.println("Hello Lambda!") // 空括号不能省略

// 多行方法体：必须用花括号包裹，且需要显式 return（如果有返回值）
(a, b) -> {
    System.out.println("Comparing: " + a + " vs " + b); // 打印调试信息
    int result = a.compareTo(b);                         // 执行比较
    return result;                                        // 显式返回结果
}

String prefix = "Hello, ";  // 这个变量在后续没有被修改，是 effectively final
 
// Lambda 捕获了外部变量 prefix
Function<String, String> greeter = name -> prefix + name; // 合法：prefix 是 effectively final
 
System.out.println(greeter.apply("Java")); // 输出: Hello, Java

String prefix = "Hello, ";
prefix = "Hi, ";  // 修改了！不再是 effectively final
 
// 编译错误：Variable used in lambda expression should be final or effectively final
Function<String, String> greeter = name -> prefix + name; // ❌ 编译失败

public class Counter {
    private int count = 0; // 实例变量，存储在堆上
 
    public void increment() {
        // Lambda 可以读写实例变量，不要求 effectively final
        Runnable r = () -> count++; // 合法：实例变量不受限制
        r.run();
        System.out.println(count); // 输出: 1
    }
}

// ┌─────────────── Stack (线程私有) ───────────────┐
// │                                                 │
// │  局部变量 prefix = "Hello, "  ← 必须 effectively final │
// │  Lambda 捕获的是 prefix 的【副本】               │
// │                                                 │
// └─────────────────────────────────────────────────┘
//
// ┌─────────────── Heap (线程共享) ────────────────┐
// │                                                 │
// │  实例变量 this.count = 0  ← 无 final 限制       │
// │  Lambda 通过 this 引用直接访问                   │
// │                                                 │
// └─────────────────────────────────────────────────┘

public class ThisDemo {
    private String name = "OuterClass"; // 外围类的字段
 
    public void test() {
        // 匿名内部类中的 this —— 指向匿名内部类实例
        Runnable anon = new Runnable() {
            @Override
            public void run() {
                // this 指向这个 Runnable 匿名类的实例
                System.out.println(this.getClass().getSimpleName()); // 输出: "" (匿名类无名)
            }
        };
 
        // Lambda 中的 this —— 指向外围类 ThisDemo 的实例
        Runnable lambda = () -> {
            // this 指向 ThisDemo 的实例，而非 Lambda 本身
            System.out.println(this.name); // 输出: OuterClass
        };
 
        anon.run();
        lambda.run();
    }
}

import java.util.Arrays;  // 导入 Arrays 工具类
import java.util.List;     // 导入 List 接口
 
public class LambdaSyntaxDemo {
    public static void main(String[] args) {
        // 准备测试数据
        List<String> languages = Arrays.asList(
            "Java", "Python", "Go", "Rust", "Kotlin", "C++"
        );
 
        // ========== 1. 遍历（forEach + Lambda） ==========
        // 传统 for-each 循环
        for (String lang : languages) {       // 传统写法：需要声明循环变量
            System.out.println(lang);
        }
 
        // Lambda 写法：行为作为参数传递给 forEach
        languages.forEach(lang -> System.out.println(lang)); // 简洁：一行搞定遍历
 
        // ========== 2. 排序（sort + Lambda） ==========
        // 按字符串长度排序
        languages.sort((a, b) -> a.length() - b.length()); // 短的排前面
        System.out.println(languages); // [Go, C++, Java, Rust, Python, Kotlin]
 
        // ========== 3. 过滤 + 转换（Stream + Lambda） ==========
        languages.stream()                                   // 创建流
            .filter(lang -> lang.length() > 3)               // 过滤：只保留长度 > 3 的
            .map(lang -> lang.toUpperCase())                  // 转换：全部转大写
            .forEach(lang -> System.out.println(lang));       // 输出：JAVA RUST PYTHON KOTLIN
    }
}

// 使用 @FunctionalInterface 注解标记这是一个函数式接口
@FunctionalInterface
public interface Greeting {
    // 有且仅有一个抽象方法 —— 这是函数式接口的核心约束
    void sayHello(String name);
}

public class GreetingDemo {
    public static void main(String[] args) {
        // Lambda 表达式会被自动推断为 Greeting 接口的实现
        // 编译器看到目标类型是 Greeting，就知道 Lambda 对应的是 sayHello 方法
        Greeting greeting = (name) -> System.out.println("你好, " + name + "!");
 
        // 调用接口方法，实际执行的是 Lambda 中定义的逻辑
        greeting.sayHello("张三"); // 输出: 你好, 张三!
    }
}

@FunctionalInterface
public interface Greeting {
    void sayHello(String name);
}

@FunctionalInterface
public interface BadInterface {
    void methodA();  // 第一个抽象方法
    void methodB();  // 第二个抽象方法 —— 编译报错！
    // 错误信息: Multiple non-overriding abstract methods found in interface BadInterface
}

@FunctionalInterface
public interface SmartGreeting {
 
    // 唯一的抽象方法 —— SAM
    String greet(String name);
 
    // default 方法：有方法体，不计入 SAM 计数
    default String greetLoudly(String name) {
        // 内部复用抽象方法的逻辑，转为大写输出
        return greet(name).toUpperCase();
    }
 
    // static 方法：属于接口本身，不计入 SAM 计数
    static String defaultGreeting() {
        return "Hello, World!";
    }
}

public class SmartGreetingDemo {
    public static void main(String[] args) {
        // Lambda 只需要实现唯一的抽象方法 greet
        SmartGreeting sg = (name) -> "你好, " + name;
 
        // 调用抽象方法（Lambda 实现）
        System.out.println(sg.greet("李四"));        // 输出: 你好, 李四
 
        // 调用 default 方法（内部会委托给 Lambda 实现的 greet）
        System.out.println(sg.greetLoudly("李四"));   // 输出: 你好, 李四 （大写）
 
        // 调用 static 方法（通过接口名直接调用）
        System.out.println(SmartGreeting.defaultGreeting()); // 输出: Hello, World!
    }
}

@FunctionalInterface
public interface Identifiable {
 
    // 唯一的抽象方法 —— SAM
    String getId();
 
    // 虽然声明为抽象方法，但 toString() 来自 Object，不计入 SAM
    String toString();
 
    // 同理，equals() 来自 Object，不计入 SAM
    boolean equals(Object obj);
 
    // 同理，hashCode() 来自 Object，不计入 SAM
    int hashCode();
}

@FunctionalInterface
interface A {
    void execute(); // A 的抽象方法
}
 
// B 继承 A，没有新增抽象方法，SAM 仍然是 execute()
@FunctionalInterface
interface B extends A {
    // 合法：继承了 A 的 execute()，总共还是 1 个抽象方法
}
 
// C 继承 A，但新增了一个抽象方法 —— 总共 2 个，不再是函数式接口
// @FunctionalInterface  // 如果加上这个注解，编译报错
interface C extends A {
    void anotherMethod(); // 第二个抽象方法，破坏了 SAM 约束
}

@FunctionalInterface
interface Parent {
    Object transform(String s); // 返回 Object
}
 
@FunctionalInterface
interface Child extends Parent {
    // 用更具体的返回类型覆盖了父接口的方法（协变返回类型）
    // 这不算新增抽象方法，SAM 仍然只有 1 个
    String transform(String s); // 返回 String（String 是 Object 的子类）
}

@FunctionalInterface
interface StringProcessor {
    // 接收一个 String，返回一个 String
    String process(String input);
}
 
@FunctionalInterface
interface StringValidator {
    // 接收一个 String，返回一个 boolean
    boolean validate(String input);
}
 
public class TargetTypingDemo {
    public static void main(String[] args) {
        // 同样的参数形式 (s) -> ...，但目标类型不同，Lambda 的含义也不同
 
        // 目标类型是 StringProcessor → Lambda 实现的是 process(String): String
        StringProcessor processor = (s) -> s.toUpperCase();
 
        // 目标类型是 StringValidator → Lambda 实现的是 validate(String): boolean
        StringValidator validator = (s) -> s.length() > 5;
 
        System.out.println(processor.process("hello"));    // 输出: HELLO
        System.out.println(validator.validate("hello"));    // 输出: false
        System.out.println(validator.validate("hello world")); // 输出: true
    }
}

public class TargetTypingContexts {
 
    // ① 变量赋值 —— 变量声明的类型就是目标类型
    static Runnable r = () -> System.out.println("赋值上下文");
 
    // ② 方法参数 —— 形参类型就是目标类型
    static void execute(Runnable task) {
        task.run();
    }
 
    // ③ 返回值 —— 方法返回类型就是目标类型
    static Comparator<String> getComparator() {
        return (s1, s2) -> s1.length() - s2.length();
    }
 
    // ④ 强制转型 —— 转型目标就是目标类型
    static void castExample() {
        Object obj = (Runnable) () -> System.out.println("强转上下文");
    }
 
    public static void main(String[] args) {
        r.run();                          // 输出: 赋值上下文
        execute(() -> System.out.println("参数上下文")); // 输出: 参数上下文
 
        Comparator<String> cmp = getComparator();
        // "cat" 长度 3, "elephant" 长度 8, 3 - 8 < 0, 所以 "cat" 排前面
        System.out.println(cmp.compare("cat", "elephant")); // 输出: -5
    }
}

import java.util.function.*;
 
public class CoreInterfacePreview {
    public static void main(String[] args) {
 
        // Function<T, R>: 接收 T，返回 R —— "转换器"
        Function<String, Integer> strLen = (s) -> s.length();
        System.out.println(strLen.apply("Lambda")); // 输出: 6
 
        // Consumer<T>: 接收 T，无返回 —— "消费者"
        Consumer<String> printer = (s) -> System.out.println("消费: " + s);
        printer.accept("数据"); // 输出: 消费: 数据
 
        // Supplier<T>: 无参数，返回 T —— "供应商"
        Supplier<Double> randomNum = () -> Math.random();
        System.out.println(randomNum.get()); // 输出: 0.xxxx（随机数）
 
        // Predicate<T>: 接收 T，返回 boolean —— "判断器"
        Predicate<Integer> isPositive = (n) -> n > 0;
        System.out.println(isPositive.test(42));  // 输出: true
        System.out.println(isPositive.test(-1));  // 输出: false
    }
}

// 自定义一个可以抛出受检异常的函数式接口
@FunctionalInterface
public interface ThrowingFunction<T, R> {
    // 与 Function 类似，但允许抛出 Exception
    R apply(T t) throws Exception;
 
    // 提供一个便捷的 static 方法，将 ThrowingFunction 转为普通 Function
    // 异常会被包装为 RuntimeException 重新抛出
    static <T, R> Function<T, R> unchecked(ThrowingFunction<T, R> f) {
        return (t) -> {
            try {
                // 尝试执行可能抛异常的逻辑
                return f.apply(t);
            } catch (Exception e) {
                // 将受检异常包装为非受检异常
                throw new RuntimeException(e);
            }
        };
    }
}

import java.util.List;
import java.util.stream.Collectors;
 
public class ThrowingFunctionDemo {
    public static void main(String[] args) {
        List<String> paths = List.of("/tmp/a.txt", "/tmp/b.txt");
 
        // 如果直接在 Stream 中使用会抛受检异常的 Lambda，编译不通过
        // paths.stream().map(p -> new File(p).getCanonicalPath()) // 编译错误！
 
        // 使用 unchecked 包装后，就可以在 Stream 中优雅地使用了
        List<String> canonicalPaths = paths.stream()
                .map(ThrowingFunction.unchecked(p -> new java.io.File(p).getCanonicalPath()))
                .collect(Collectors.toList());
 
        canonicalPaths.forEach(System.out::println);
    }
}

// 比起 Predicate<Order>，OrderFilter 的语义更加清晰
@FunctionalInterface
public interface OrderFilter {
    // 判断订单是否满足筛选条件
    boolean matches(Order order);
}
 
// 比起 Function<Event, Result>，EventHandler 更能表达意图
@FunctionalInterface
public interface EventHandler<E, R> {
    // 处理事件并返回结果
    R handle(E event);
}

public class LambdaVsAnonymous {
    // 成员变量，用于演示 this 指向
    String name = "外部类实例";
 
    public void demonstrate() {
 
        // ========== 匿名内部类 ==========
        Runnable anonymous = new Runnable() {
            String name = "匿名类实例";
 
            @Override
            public void run() {
                // this 指向匿名内部类自身的实例
                System.out.println("匿名类 this.name = " + this.name);
                // 输出: 匿名类 this.name = 匿名类实例
            }
        };
 
        // ========== Lambda 表达式 ==========
        Runnable lambda = () -> {
            // this 指向外围类（LambdaVsAnonymous）的实例
            System.out.println("Lambda this.name = " + this.name);
            // 输出: Lambda this.name = 外部类实例
        };
 
        anonymous.run();
        lambda.run();
    }
 
    public static void main(String[] args) {
        new LambdaVsAnonymous().demonstrate();
    }
}

public class VariableCaptureDemo {
    public static void main(String[] args) {
        // effectively final：声明后没有再被修改过
        String greeting = "Hello";
 
        // 可变变量
        int counter = 0;
 
        // ✅ 合法：greeting 是 effectively final
        Runnable r1 = () -> System.out.println(greeting + ", Lambda!");
 
        // ❌ 编译错误：counter 在后面被修改了，不再是 effectively final
        // Runnable r2 = () -> System.out.println(counter);
 
        counter++; // 这一行导致 counter 不再是 effectively final
 
        r1.run(); // 输出: Hello, Lambda!
 
        // 如果确实需要在 Lambda 中使用可变状态，可以用数组或 AtomicInteger 包装
        int[] mutableCounter = {0}; // 数组引用本身是 effectively final
        Runnable r3 = () -> {
            mutableCounter[0]++; // 修改的是数组元素，不是数组引用
            System.out.println("计数: " + mutableCounter[0]);
        };
        r3.run(); // 输出: 计数: 1
        r3.run(); // 输出: 计数: 2
    }
}

@FunctionalInterface
interface A {
    void doA();
    void doB();
}

@FunctionalInterface
interface B {
    void execute();
    default void log() { System.out.println("log"); }
    static void info() { System.out.println("info"); }
}

@FunctionalInterface
interface C {
    void run();
    String toString();
    boolean equals(Object o);
    default void help() {}
}

// ========== 示例 1：基础类型转换 ==========
 
// Lambda 写法：接收一个 String，返回一个 Integer
// Function<String, Integer> parser = (String s) -> Integer.parseInt(s);
 
// 方法引用写法：直接指向 Integer 类的静态方法 parseInt
// 编译器自动推断：参数 s 传给 parseInt，返回值就是 parseInt 的返回值
Function<String, Integer> parser = Integer::parseInt;
 
// 调用 apply 时，实际执行的就是 Integer.parseInt("42")
int result = parser.apply("42"); // result = 42

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class StaticMethodRefDemo {
 
    // 自定义的静态工具方法：判断一个数是否为偶数
    public static boolean isEven(int number) {
        return number % 2 == 0; // 能被 2 整除即为偶数
    }
 
    // 自定义的静态工具方法：将数字翻倍
    public static int doubleIt(int number) {
        return number * 2; // 简单地乘以 2
    }
 
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
 
        List<Integer> result = numbers.stream()
                // filter 需要 Predicate<Integer>，即 (Integer) -> boolean
                // isEven 签名：(int) -> boolean，自动拆箱后完全匹配
                .filter(StaticMethodRefDemo::isEven)
                // map 需要 Function<Integer, Integer>，即 (Integer) -> Integer
                // doubleIt 签名：(int) -> int，自动装拆箱后匹配
                .map(StaticMethodRefDemo::doubleIt)
                // 收集为 List
                .collect(Collectors.toList());
 
        // 输出：[4, 8, 12, 16]
        // 过程：筛出偶数 [2,4,6,8] → 各自翻倍 [4,8,12,16]
        System.out.println(result);
    }
}

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
 
public class SortWithStaticRef {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Charlie", "Alice", "Bob", "David");
 
        // String::compareToIgnoreCase 其实是"类实例方法引用"（第三种形式）
        // 这里我们用一个自定义静态方法来演示"静态方法引用"做排序
 
        // 按字符串长度排序的静态方法
        // 签名与 Comparator<String> 的 compare(String, String) -> int 一致
        // names.sort(SortWithStaticRef::compareByLength);
 
        // 但更常见的做法是用 Comparator.comparingInt 这个静态工厂方法
        // comparingInt 接收 ToIntFunction<String>，即 (String) -> int
        // String::length 是"类实例方法引用"，这里先感受一下混合使用
        names.sort(Comparator.comparingInt(String::length));
 
        // 输出：[Bob, Alice, David, Charlie]
        System.out.println(names);
    }
 
    // 自定义的静态比较方法
    public static int compareByLength(String a, String b) {
        return Integer.compare(a.length(), b.length()); // 按长度升序
    }
}

// ========== 基础示例 ==========
 
// 创建一个具体的 String 对象
String prefix = "Hello, ";
 
// Lambda 写法：
// Function<String, String> greeter = (name) -> prefix.concat(name);
 
// 实例方法引用写法：prefix 这个对象在此刻被"捕获"
// concat 是 String 的实例方法，签名：(String) -> String
// 与 Function<String, String> 的 apply(String) -> String 完全匹配
Function<String, String> greeter = prefix::concat;
 
// 调用时，实际执行的是 "Hello, ".concat("World")
String result = greeter.apply("World"); // result = "Hello, World"

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
 
public class InstanceMethodRefDemo {
 
    public static void main(String[] args) {
 
        // ========== 场景 1：用 System.out 的实例方法 println ==========
        // System.out 是 PrintStream 类型的一个具体对象实例
        // println 是 PrintStream 的实例方法
        // Consumer<String> 需要 (String) -> void，println(String) 正好匹配
        List<String> languages = Arrays.asList("Java", "Kotlin", "Scala");
 
        // Lambda 写法：languages.forEach(lang -> System.out.println(lang));
        // 实例方法引用：System.out 是 receiver，println 是方法
        languages.forEach(System.out::println);
        // 输出：
        // Java
        // Kotlin
        // Scala
 
 
        // ========== 场景 2：自定义对象的实例方法 ==========
        StringChecker checker = new StringChecker("Java");
 
        List<String> words = Arrays.asList("Java", "Python", "Java", "Go", "Java");
 
        // checker::matches 捕获了 checker 对象
        // Predicate<String> 需要 (String) -> boolean
        // matches 签名：(String) -> boolean，完全匹配
        long count = words.stream()
                .filter(checker::matches) // 等价于 word -> checker.matches(word)
                .count();
 
        // 输出：3（"Java" 出现了 3 次）
        System.out.println("匹配次数: " + count);
 
 
        // ========== 场景 3：在不同上下文中复用同一个方法引用 ==========
        StringBuilder logger = new StringBuilder();
 
        // logger::append 捕获了 logger 对象
        // Consumer<String> 需要 (String) -> void
        // 但 append 返回 StringBuilder，不是 void？
        // 没关系！Java 允许忽略返回值，签名依然兼容
        Consumer<String> logAction = logger::append;
 
        logAction.accept("Step1 ");  // logger 内容变为 "Step1 "
        logAction.accept("Step2 ");  // logger 内容变为 "Step1 Step2 "
        logAction.accept("Step3");   // logger 内容变为 "Step1 Step2 Step3"
 
        System.out.println(logger.toString()); // 输出：Step1 Step2 Step3
    }
}
 
// 辅助类：封装字符串匹配逻辑
class StringChecker {
    private final String target; // 要匹配的目标字符串
 
    // 构造器：初始化目标字符串
    public StringChecker(String target) {
        this.target = target;
    }
 
    // 实例方法：判断传入的字符串是否与目标相等
    public boolean matches(String input) {
        return target.equals(input); // 使用 equals 进行内容比较
    }
}

import java.util.function.Supplier;
 
public class CaptureTimingDemo {
    public static void main(String[] args) {
 
        StringBuilder sb = new StringBuilder("Hello");
 
        // 此刻捕获的是 sb 指向的那个 StringBuilder 对象
        // Supplier<String> 需要 () -> String
        // toString 签名：() -> String，完全匹配
        Supplier<String> supplier = sb::toString;
 
        // 修改同一个对象的内容
        sb.append(" World");
 
        // supplier 仍然引用同一个 StringBuilder 对象
        // 所以能看到修改后的内容
        System.out.println(supplier.get()); // 输出：Hello World
 
        // 但如果我们让 sb 指向一个新对象...
        sb = new StringBuilder("Completely New");
 
        // supplier 捕获的还是旧对象（"Hello World" 那个）
        // 变量 sb 的重新赋值不影响已捕获的引用
        System.out.println(supplier.get()); // 输出：Hello World
    }
}

import java.util.function.Function;
import java.util.function.UnaryOperator;
 
public class ComparisonDemo {
    public static void main(String[] args) {
 
        // ===== 静态方法引用 =====
        // String.valueOf 是静态方法，签名：(int) -> String
        // Function<Integer, String> 的 apply(Integer) -> String 与之匹配
        Function<Integer, String> staticRef = String::valueOf;
        System.out.println(staticRef.apply(42)); // "42"
 
        // ===== 实例方法引用 =====
        String base = "HELLO";
        // base 是具体对象，toLowerCase 是实例方法，签名：() -> String
        // 但这里没有参数？用 Supplier 更合适
        // Supplier<String> instanceRef = base::toLowerCase;
 
        // 换一个有参数的例子：
        // replace 签名：(char, char) -> String
        // 但标准函数式接口没有接收两个 char 的，我们用自定义的
        // 更实际的例子：
        String prefix2 = "[LOG] ";
        // concat 签名：(String) -> String
        // UnaryOperator<String> 继承 Function<String, String>
        UnaryOperator<String> instanceRef = prefix2::concat;
        System.out.println(instanceRef.apply("Server started")); // "[LOG] Server started"
 
        // 关键区别：
        // staticRef 不绑定任何对象，每次调用都是 String.valueOf(arg)
        // instanceRef 绑定了 prefix2 对象，每次调用都是 "[LOG] ".concat(arg)
    }
}

import java.util.function.Function;
import java.util.function.UnaryOperator;
 
public class Quiz {
    public static void main(String[] args) {
        String s = "hello";
        UnaryOperator<String> op = s::concat;
        s = "world";
        System.out.println(op.apply(" java"));
    }
}

// ===== 类实例方法引用：String::length =====
 
// Lambda 写法
// 这里 s 是 Lambda 的参数，同时也是 length() 的调用者
Function<String, Integer> lambdaLen = (String s) -> s.length();
 
// 方法引用写法
// String 是类名，length 是实例方法
// 编译器自动将 Function<String, Integer> 的参数 s 绑定为 length() 的调用者
Function<String, Integer> refLen = String::length;
 
// 两种写法完全等价
System.out.println(lambdaLen.apply("Hello")); // 5
System.out.println(refLen.apply("Hello"));    // 5

// ===== 双参数场景：String::compareTo =====
 
// compareTo 是 String 的实例方法，签名为 int compareTo(String anotherString)
// 它需要一个调用者 + 一个参数，总共"消耗"两个 String
 
// Lambda 写法
// a 是调用者，b 是 compareTo 的参数
BiFunction<String, String, Integer> lambdaCmp = (a, b) -> a.compareTo(b);
 
// 方法引用写法
// 编译器自动将第一个参数 a 绑定为调用者，第二个参数 b 传入 compareTo
BiFunction<String, String, Integer> refCmp = String::compareTo;
 
System.out.println(lambdaCmp.apply("apple", "banana")); // 负数，因为 "apple" < "banana"
System.out.println(refCmp.apply("apple", "banana"));    // 同上

// ===== 类实例方法引用的参数映射公式 =====
 
// 假设函数式接口的抽象方法签名为：
// R apply(T arg0, U arg1, V arg2, ...)
 
// 类实例方法引用 T::methodName 等价于：
// (T arg0, U arg1, V arg2, ...) -> arg0.methodName(arg1, arg2, ...)
//   ↑ 第一个参数变成调用者          ↑ 剩余参数传给方法
 
// 所以参数数量关系为：
// 函数式接口参数个数 = 1（调用者） + 实例方法的参数个数

import java.util.Arrays;
import java.util.List;
 
public class ClassInstanceMethodRefDemo {
    public static void main(String[] args) {
 
        // ===== 场景一：排序 =====
        List<String> names = Arrays.asList("Charlie", "Alice", "Bob");
 
        // Lambda 写法
        // Comparator<String> 的 compare(String a, String b)
        // a 是调用者，b 是参数
        names.sort((a, b) -> a.compareToIgnoreCase(b));
 
        // 方法引用写法 —— 简洁得多
        names.sort(String::compareToIgnoreCase);
        // 排序结果：[Alice, Bob, Charlie]
        System.out.println(names);
 
 
        // ===== 场景二：Stream 中的 map =====
        List<String> words = Arrays.asList("hello", "world", "java");
 
        // 将每个字符串转为大写
        // Lambda: s -> s.toUpperCase()
        // 方法引用: String::toUpperCase
        List<String> upper = words.stream()
                .map(String::toUpperCase) // 第一个参数（流中的元素）成为 toUpperCase() 的调用者
                .toList();
        // 结果：[HELLO, WORLD, JAVA]
        System.out.println(upper);
 
 
        // ===== 场景三：判断字符串是否以某前缀开头 =====
        // startsWith(String prefix) 是实例方法，需要一个调用者 + 一个参数
        // 所以对应 BiFunction 或 BiPredicate
        // BiPredicate<String, String> 的 test(String a, String b)
        // 等价于 (a, b) -> a.startsWith(b)
        java.util.function.BiPredicate<String, String> startsWith = String::startsWith;
 
        System.out.println(startsWith.test("JavaScript", "Java")); // true
        System.out.println(startsWith.test("Python", "Java"));     // false
    }
}

// ===== 易混淆对比 =====
 
String greeting = "Hello";
 
// 1. 实例方法引用（obj::method）
//    greeting 是一个具体的对象实例，concat 绑定到这个对象上
//    等价于 (String s) -> greeting.concat(s)
//    调用者已经确定了，参数 s 传给 concat
Function<String, String> bound = greeting::concat;
System.out.println(bound.apply(" World")); // "Hello World"
 
// 2. 类实例方法引用（Class::method）
//    String 是类名，concat 没有绑定到任何对象
//    等价于 (String a, String b) -> a.concat(b)
//    第一个参数 a 成为调用者，第二个参数 b 传给 concat
BiFunction<String, String, String> unbound = String::concat;
System.out.println(unbound.apply("Hello", " World")); // "Hello World"
 
// 两者结果相同，但参数个数不同！
// bound 只需要 1 个参数（调用者已绑定）
// unbound 需要 2 个参数（调用者从第一个参数取）

// ===== 记忆口诀 =====
// obj::method  → 调用者已锁定，参数少一个（bound reference）
// Class::method → 调用者从参数取，参数多一个（unbound reference）

// ===== 构造方法引用基础 =====
 
// Lambda 写法：调用 String 的无参构造器
Supplier<String> lambdaNew = () -> new String();
 
// 构造方法引用写法
// 编译器看到 String::new，会根据函数式接口的签名选择匹配的构造器
// Supplier<String> 的 get() 无参数 → 匹配 String 的无参构造器
Supplier<String> refNew = String::new;
 
// 两者等价
System.out.println(lambdaNew.get()); // ""（空字符串）
System.out.println(refNew.get());    // ""（空字符串）

// ===== 根据函数式接口自动匹配不同构造器 =====
 
// 1. 无参构造器
//    Supplier<T> 的 get() 没有参数 → 匹配 StringBuilder()
Supplier<StringBuilder> noArg = StringBuilder::new;
// 等价于 () -> new StringBuilder()
System.out.println(noArg.get().capacity()); // 16（默认容量）
 
// 2. 单参数构造器
//    Function<T, R> 的 apply(T t) 有一个参数 → 匹配 StringBuilder(int capacity)
Function<Integer, StringBuilder> oneArg = StringBuilder::new;
// 等价于 (Integer capacity) -> new StringBuilder(capacity)
System.out.println(oneArg.apply(64).capacity()); // 64
 
// 3. 单参数构造器（不同类型）
//    Function<String, StringBuilder> → 匹配 StringBuilder(String str)
Function<String, StringBuilder> fromStr = StringBuilder::new;
// 等价于 (String s) -> new StringBuilder(s)
System.out.println(fromStr.apply("Hello")); // "Hello"
 
// 4. 双参数场景需要 BiFunction
//    假设有一个类 Point(int x, int y)
//    BiFunction<Integer, Integer, Point> → 匹配 Point(int, int)

// ===== 自定义类演示 =====
 
class Student {
    private String name; // 学生姓名
    private int age;     // 学生年龄
 
    // 无参构造器
    public Student() {
        this.name = "Unknown";
        this.age = 0;
    }
 
    // 单参数构造器
    public Student(String name) {
        this.name = name;
        this.age = 0;
    }
 
    // 双参数构造器
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + "}";
    }
}

// ===== 使用构造方法引用创建 Student =====
 
import java.util.function.*;
 
public class ConstructorRefDemo {
    public static void main(String[] args) {
 
        // 匹配无参构造器 Student()
        Supplier<Student> s0 = Student::new;
        System.out.println(s0.get());
        // 输出: Student{name='Unknown', age=0}
 
        // 匹配单参数构造器 Student(String)
        Function<String, Student> s1 = Student::new;
        System.out.println(s1.apply("Alice"));
        // 输出: Student{name='Alice', age=0}
 
        // 匹配双参数构造器 Student(String, int)
        BiFunction<String, Integer, Student> s2 = Student::new;
        System.out.println(s2.apply("Bob", 20));
        // 输出: Student{name='Bob', age=20}
    }
}

import java.util.*;
import java.util.stream.*;
 
public class ConstructorRefPractical {
    public static void main(String[] args) {
 
        // ===== 场景一：Stream 中批量创建对象 =====
        List<String> nameList = Arrays.asList("Alice", "Bob", "Charlie");
 
        // 将名字列表转换为 Student 对象列表
        // map(Student::new) 等价于 map(name -> new Student(name))
        // 这里自动匹配 Student(String) 构造器
        List<Student> students = nameList.stream()
                .map(Student::new)       // 构造方法引用，简洁优雅
                .collect(Collectors.toList());
        // 结果: [Student{name='Alice'...}, Student{name='Bob'...}, ...]
        System.out.println(students);
 
 
        // ===== 场景二：作为工厂函数传递 =====
        // 定义一个通用的创建方法，接受一个"工厂"参数
        Student s = createWithFactory(Student::new, "Diana");
        System.out.println(s); // Student{name='Diana', age=0}
 
 
        // ===== 场景三：创建数组 =====
        // 数组构造方法引用的特殊语法：Type[]::new
        // 等价于 (int size) -> new String[size]
        // IntFunction<String[]> 的 apply(int) 返回 String[]
        String[] arr = nameList.stream()
                .toArray(String[]::new); // 数组构造方法引用
        // 结果: ["Alice", "Bob", "Charlie"]
        System.out.println(Arrays.toString(arr));
    }
 
    // 通用工厂方法：接受一个 Function 作为"构造器"
    static Student createWithFactory(Function<String, Student> factory, String name) {
        return factory.apply(name); // 内部调用 factory，实际执行的是 new Student(name)
    }
}

// ===== 数组构造方法引用详解 =====
 
// Stream 的 toArray() 方法签名：
// <A> A[] toArray(IntFunction<A[]> generator)
// 它需要一个 IntFunction，接收数组长度，返回对应类型的数组
 
// Lambda 写法
String[] a1 = Stream.of("a", "b", "c").toArray(size -> new String[size]);
 
// 数组构造方法引用 —— 更简洁
String[] a2 = Stream.of("a", "b", "c").toArray(String[]::new);
 
// 对于基本类型包装类也一样
Integer[] nums = Stream.of(1, 2, 3).toArray(Integer[]::new);

// ===== 四种方法引用速查 =====
// 1. Class::staticMethod   → 静态方法引用    → 参数全部传给方法
// 2. obj::method           → 实例方法引用    → 调用者已绑定，参数传给方法
// 3. Class::method         → 类实例方法引用  → 第一个参数当调用者，其余传给方法
// 4. Class::new            → 构造方法引用    → 参数传给匹配的构造器

import java.util.function.*;
 
public class Quiz {
    public static void main(String[] args) {
        BiFunction<String, String, String> fn = String::concat;
        String result = fn.apply("Hello, ", "World!");
        System.out.println(result);
    }
}

@FunctionalInterface
public interface Function<T, R> {
    // 核心抽象方法：接收 T，返回 R
    R apply(T t);
 
    // 默认方法：先执行 before，再执行当前函数（组合）
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v)); // before 的输出作为当前函数的输入
    }
 
    // 默认方法：先执行当前函数，再执行 after（链式）
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t)); // 当前函数的输出作为 after 的输入
    }
 
    // 静态方法：返回一个"恒等函数"，输入什么就输出什么
    static <T> Function<T, T> identity() {
        return t -> t; // 等价于 x -> x
    }
}

import java.util.function.Function;
 
public class FunctionDemo {
    public static void main(String[] args) {
 
        // ========== 场景1：基本类型转换 ==========
        // 将字符串转换为其长度（String → Integer）
        Function<String, Integer> strToLength = str -> str.length();
        // 调用 apply 执行转换
        int len = strToLength.apply("Lambda"); // 结果：6
        System.out.println("长度: " + len);    // 输出: 长度: 6
 
        // ========== 场景2：用方法引用简化 ==========
        // String::length 等价于 str -> str.length()
        Function<String, Integer> strToLength2 = String::length;
        System.out.println(strToLength2.apply("Java")); // 输出: 4
 
        // ========== 场景3：链式调用 andThen ==========
        // 第一步：字符串 → 长度
        Function<String, Integer> length = String::length;
        // 第二步：长度 → 乘以2
        Function<Integer, Integer> doubleIt = n -> n * 2;
        // 组合：先求长度，再乘以2
        Function<String, Integer> lengthThenDouble = length.andThen(doubleIt);
        System.out.println(lengthThenDouble.apply("Hello")); // 5 * 2 = 10
 
        // ========== 场景4：compose（反向组合）==========
        // compose 是 andThen 的"镜像"：先执行参数函数，再执行自己
        Function<String, String> trim = String::trim;           // 去空格
        Function<String, String> toUpper = String::toUpperCase; // 转大写
        // toUpper.compose(trim) 等价于 trim.andThen(toUpper)
        Function<String, String> trimThenUpper = toUpper.compose(trim);
        System.out.println(trimThenUpper.apply("  hello  ")); // 输出: HELLO
 
        // ========== 场景5：identity 恒等函数 ==========
        // 常用于需要传入 Function 但不想做任何转换的场景
        Function<String, String> noOp = Function.identity();
        System.out.println(noOp.apply("原样返回")); // 输出: 原样返回
    }
}

import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
 
public class FunctionInStream {
    public static void main(String[] args) {
        List<String> names = List.of("alice", "bob", "charlie");
 
        // map() 的参数就是 Function<T, R>
        // 这里 T = String, R = String
        List<String> upperNames = names.stream()
                .map(String::toUpperCase)  // Function<String, String>
                .collect(Collectors.toList());
        // 结果: [ALICE, BOB, CHARLIE]
        System.out.println(upperNames);
 
        // 也可以传入自定义的 Function
        Function<String, String> addGreeting = name -> "Hello, " + name + "!";
        List<String> greetings = names.stream()
                .map(String::toUpperCase)   // 先转大写
                .map(addGreeting)           // 再加问候语
                .collect(Collectors.toList());
        // 结果: [Hello, ALICE!, Hello, BOB!, Hello, CHARLIE!]
        System.out.println(greetings);
    }
}

import java.util.function.BiFunction;
import java.util.function.UnaryOperator;
import java.util.function.IntFunction;
import java.util.function.ToIntFunction;
 
public class FunctionVariants {
    public static void main(String[] args) {
 
        // BiFunction<T, U, R>：接收两个参数，返回一个结果
        // 相当于 f(x, y) = z
        BiFunction<String, Integer, String> repeat =
                (str, times) -> str.repeat(times); // 将字符串重复 n 次
        System.out.println(repeat.apply("Ha", 3)); // 输出: HaHaHa
 
        // UnaryOperator<T>：输入输出类型相同的 Function
        // 本质上是 Function<T, T> 的特化
        UnaryOperator<String> shout = s -> s + "!!!";
        System.out.println(shout.apply("Java")); // 输出: Java!!!
 
        // IntFunction<R>：接收 int 基本类型，避免自动装箱
        IntFunction<String> intToStr = num -> "Number: " + num;
        System.out.println(intToStr.apply(42)); // 输出: Number: 42
 
        // ToIntFunction<T>：返回 int 基本类型，避免自动装箱
        ToIntFunction<String> parseLen = String::length;
        int result = parseLen.applyAsInt("Lambda"); // 注意方法名是 applyAsInt
        System.out.println(result); // 输出: 6
    }
}

import java.util.function.Function;
 
public class PipelineDemo {
 
    // 泛型方法：接收一个值和一系列转换函数，依次执行
    @SafeVarargs
    public static <T> T pipeline(T value, Function<T, T>... steps) {
        T result = value; // 初始值
        for (Function<T, T> step : steps) {
            result = step.apply(result); // 逐步应用每个转换
        }
        return result; // 返回最终结果
    }
 
    public static void main(String[] args) {
        // 定义三个独立的转换步骤
        Function<String, String> trim = String::trim;           // 步骤1：去空格
        Function<String, String> lower = String::toLowerCase;   // 步骤2：转小写
        Function<String, String> addTag = s -> "[LOG] " + s;    // 步骤3：加标签
 
        // 通过管道依次执行
        String result = pipeline("  HELLO WORLD  ", trim, lower, addTag);
        System.out.println(result); // 输出: [LOG] hello world
 
        // 也可以用 andThen 实现同样效果（函数组合方式）
        Function<String, String> combined = trim.andThen(lower).andThen(addTag);
        System.out.println(combined.apply("  HELLO WORLD  ")); // 输出: [LOG] hello world
    }
}

@FunctionalInterface
public interface Consumer<T> {
    // 核心抽象方法：接收 T，无返回值
    void accept(T t);
 
    // 默认方法：先执行当前 Consumer，再执行 after
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        // 对同一个输入 t，依次执行两个 Consumer
        return (T t) -> {
            accept(t);       // 先执行自己
            after.accept(t); // 再执行 after
        };
    }
}

import java.util.function.Consumer;
import java.util.List;
 
public class ConsumerDemo {
    public static void main(String[] args) {
 
        // ========== 场景1：最简单的消费——打印 ==========
        Consumer<String> printer = s -> System.out.println(s);
        printer.accept("Hello Consumer"); // 输出: Hello Consumer
 
        // 用方法引用更简洁
        Consumer<String> printer2 = System.out::println;
        printer2.accept("方法引用版本"); // 输出: 方法引用版本
 
        // ========== 场景2：andThen 链式消费 ==========
        // 对同一个输入执行多个操作
        Consumer<String> log = s -> System.out.println("[LOG] " + s);   // 记录日志
        Consumer<String> save = s -> System.out.println("[SAVE] " + s); // 模拟保存
        Consumer<String> notify = s -> System.out.println("[NOTIFY] " + s); // 模拟通知
 
        // 链式：对同一条消息，先记日志，再保存，再通知
        Consumer<String> fullProcess = log.andThen(save).andThen(notify);
        fullProcess.accept("用户注册成功");
        // 输出:
        // [LOG] 用户注册成功
        // [SAVE] 用户注册成功
        // [NOTIFY] 用户注册成功
 
        // ========== 场景3：配合 forEach 使用 ==========
        List<String> fruits = List.of("Apple", "Banana", "Cherry");
        // Iterable.forEach() 的参数就是 Consumer<T>
        fruits.forEach(System.out::println);
        // 输出:
        // Apple
        // Banana
        // Cherry
 
        // 自定义 Consumer 传入 forEach
        Consumer<String> fancyPrint = fruit -> System.out.println("🍎 " + fruit);
        fruits.forEach(fancyPrint);
    }
}

import java.util.List;
import java.util.stream.Collectors;
 
public class ConsumerInStream {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
 
        // peek() 接收 Consumer<T>，用于调试/观察中间状态
        // 注意：peek 不改变流中的元素，只是"偷看"一眼
        List<Integer> doubled = numbers.stream()
                .peek(n -> System.out.println("原始值: " + n))  // Consumer：观察原始值
                .map(n -> n * 2)                                 // Function：翻倍
                .peek(n -> System.out.println("翻倍后: " + n))  // Consumer：观察翻倍后的值
                .collect(Collectors.toList());
        // 输出交替出现：原始值: 1, 翻倍后: 2, 原始值: 2, 翻倍后: 4 ...
 
        System.out.println("最终结果: " + doubled); // [2, 4, 6, 8, 10]
    }
}

import java.util.function.BiConsumer;
import java.util.function.IntConsumer;
import java.util.function.ObjIntConsumer;
import java.util.Map;
import java.util.HashMap;
 
public class ConsumerVariants {
    public static void main(String[] args) {
 
        // BiConsumer<T, U>：接收两个参数，无返回值
        // Map.forEach() 的参数就是 BiConsumer<K, V>
        Map<String, Integer> scores = new HashMap<>();
        scores.put("Alice", 95);  // 添加键值对
        scores.put("Bob", 87);    // 添加键值对
        scores.put("Charlie", 92);// 添加键值对
 
        // BiConsumer 接收 key 和 value 两个参数
        BiConsumer<String, Integer> printEntry =
                (name, score) -> System.out.println(name + " → " + score);
        scores.forEach(printEntry);
        // 输出:
        // Alice → 95
        // Bob → 87
        // Charlie → 92
 
        // IntConsumer：接收 int 基本类型，避免自动装箱
        IntConsumer printInt = n -> System.out.println("数字: " + n);
        printInt.accept(42); // 输出: 数字: 42
 
        // ObjIntConsumer<T>：一个对象参数 + 一个 int 参数
        ObjIntConsumer<String> repeatPrint =
                (str, times) -> {
                    for (int i = 0; i < times; i++) { // 循环打印指定次数
                        System.out.print(str + " ");
                    }
                    System.out.println(); // 换行
                };
        repeatPrint.accept("Hi", 3); // 输出: Hi Hi Hi
    }
}

import java.util.function.Consumer;
import java.util.ArrayList;
import java.util.List;
 
// 简易事件总线：用 Consumer 作为事件监听器
public class EventBus<T> {
    // 存储所有监听器（每个监听器就是一个 Consumer）
    private final List<Consumer<T>> listeners = new ArrayList<>();
 
    // 注册监听器
    public void on(Consumer<T> listener) {
        listeners.add(listener); // 将 Consumer 加入列表
    }
 
    // 触发事件：对同一个事件数据，依次调用所有监听器
    public void emit(T event) {
        for (Consumer<T> listener : listeners) {
            listener.accept(event); // 每个 Consumer 消费同一个事件
        }
    }
 
    public static void main(String[] args) {
        EventBus<String> bus = new EventBus<>();
 
        // 注册三个监听器（三个 Consumer）
        bus.on(msg -> System.out.println("[日志] " + msg));       // 监听器1：记日志
        bus.on(msg -> System.out.println("[统计] 消息长度: " + msg.length())); // 监听器2：统计
        bus.on(msg -> {                                            // 监听器3：告警判断
            if (msg.contains("error")) {
                System.out.println("[告警] 检测到错误信息!");
            }
        });
 
        // 触发事件
        bus.emit("用户登录成功");
        // 输出:
        // [日志] 用户登录成功
        // [统计] 消息长度: 6
        System.out.println("---");
 
        bus.emit("系统发生 error 异常");
        // 输出:
        // [日志] 系统发生 error 异常
        // [统计] 消息长度: 11
        // [告警] 检测到错误信息!
    }
}

@FunctionalInterface
public interface Supplier<T> {
    // 不接收任何参数，返回一个类型为 T 的结果
    T get();
}

import java.util.function.Supplier;
import java.time.LocalDateTime;
 
public class SupplierBasicDemo {
    public static void main(String[] args) {
        // 定义一个 Supplier：每次调用 get() 都返回当前时间
        // 注意：这里并没有立即获取时间，只是"描述了如何获取"
        Supplier<LocalDateTime> nowSupplier = () -> LocalDateTime.now();
 
        // 也可以用方法引用简化
        Supplier<LocalDateTime> nowRef = LocalDateTime::now;
 
        // 第一次调用 get()，此刻才真正执行 LocalDateTime.now()
        System.out.println("第一次获取: " + nowSupplier.get());
 
        // 模拟一段耗时操作
        try { Thread.sleep(1000); } catch (InterruptedException e) { }
 
        // 第二次调用 get()，又重新执行一次，时间已经变了
        System.out.println("第二次获取: " + nowSupplier.get());
 
        // ========== 返回固定值的 Supplier ==========
        // Supplier 也可以返回常量，虽然简单但在泛型 API 中非常有用
        Supplier<String> greeting = () -> "Hello, Lambda!";
        System.out.println(greeting.get()); // Hello, Lambda!
 
        // ========== 返回随机数的 Supplier ==========
        Supplier<Double> randomSupplier = Math::random;
        System.out.println("随机数: " + randomSupplier.get());
    }
}