Lambda 底层实现：invokedynamic 与函数式接口

// ① 匿名内部类：最冗长
Comparator<String> c1 = new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return Integer.compare(a.length(), b.length());
    }
};

// ② Lambda 完整写法：省略类名和方法名
Comparator<String> c2 = (String a, String b) -> {
    return Integer.compare(a.length(), b.length());
};

// ③ 类型推断：编译器自动推导参数类型
Comparator<String> c3 = (a, b) -> Integer.compare(a.length(), b.length());

// ④ 方法引用：最极简的写法
Comparator<String> c4 = Comparator.comparingInt(String::length);

// ① 静态方法引用：类名::静态方法名
Function<String, Integer> f1 = Integer::parseInt;

// ② 实例方法引用（已绑定）：对象::实例方法名
String str = "hello";
Supplier<Integer> f2 = str::length;

// ③ 实例方法引用（未绑定）：类名::实例方法名
Function<String, Integer> f3 = String::length;

// ④ 构造方法引用：类名::new
Supplier<ArrayList<String>> f4 = ArrayList::new;

@FunctionalInterface   // 编译期检查：确保只有一个抽象方法
public interface MyAction<T> {
    void execute(T input);        // 唯一的抽象方法

    // 可以有 default 方法 —— 不算抽象方法
    default void log(T input) { System.out.println(input); }

    // 可以有 static 方法 —— 不算抽象方法
    static <T> MyAction<T> identity() { return x -> {}; }
}

// 编译报错！如果定义了第二个抽象方法：
// void execute2(T input);  ← @FunctionalInterface 检查失败

List<String> names = List.of("Alice", "Bob", "Charlie", "David");

// Predicate —— 过滤：名字长度 > 3
Predicate<String> longName = s -> s.length() > 3;
names.stream().filter(longName).collect(Collectors.toList());
// → ["Alice", "Charlie", "David"]

// Function —— 转换：名字 → 大写
Function<String, String> toUpper = String::toUpperCase;
names.stream().map(toUpper).collect(Collectors.toList());
// → ["ALICE", "BOB", "CHARLIE", "DAVID"]

// Consumer —— 消费：打印每个名字
Consumer<String> printer = s -> System.out.println("Name: " + s);
names.forEach(printer);

// Supplier —— 生产：懒加载默认值
Supplier<List<String>> defaultList = ArrayList::new;
List<String> result = Optional.<List<String>>empty()
    .orElseGet(defaultList);

public class LambdaVsAnon {

    // 方式一：Lambda 表达式
    Runnable r1 = () -> System.out.println("lambda");

    // 方式二：匿名内部类
    Runnable r2 = new Runnable() {
        @Override
        public void run() {
            System.out.println("anonymous");
        }
    };
}

// 字段初始化中的 Lambda 编译结果：
0: invokedynamic  // 关键指令！
   #2 <run, ()Ljava/lang/Runnable;>

// 编译器生成的私有静态方法（Lambda 体）：
private static synthetic void lambda$new$0();
   0: getstatic  java/lang/System.out
   3: ldc        "lambda"
   5: invokevirtual java/io/PrintStream.println
   8: return

// 字段初始化中的匿名类编译结果：
0: new  LambdaVsAnon$1   // 创建新对象 —— 独立的类文件！
   3: dup
   4: aload_0
   5: invokespecial LambdaVsAnon$1.<init>

// 同时生成了 LambdaVsAnon$1.class 文件
// 其中包含完整的 Runnable 实现类

// javap -v 可以看到的 BootstrapMethods 区段：
BootstrapMethods:
  0: #42 invokestatic
     java/lang/invoke/LambdaMetafactory.metafactory
     (Lookup, String, MethodType, MethodType, MethodHandle, MethodType)
     → CallSite

// 三个关键参数：
//   samMethodType  → 函数式接口方法的签名
//   implMethod     → Lambda 体对应的私有方法句柄
//   instantiatedMethodType → 实例化后的具体方法签名

int factor = 10;

// 无捕获 Lambda：不引用外部变量
Function<Integer, Integer> f1 = x -> x * 2;
// → JVM 生成单例，所有调用点共享同一实例

// 有捕获 Lambda：引用了外部的 factor 变量
Function<Integer, Integer> f2 = x -> x * factor;
// → 每次调用都 new 一个新实例（factor 作为构造参数传入）

List<Order> orders = getOrders();

// 链式处理：过滤 → 转换 → 排序 → 收集
List<String> result = orders.stream()
    .filter(o -> o.getAmount() > 100)           // Predicate
    .map(Order::getProductName)                  // Function
    .sorted(String::compareTo)                   // Comparator
    .distinct()                                  // 去重
    .collect(Collectors.toList());

List<Employee> employees = getEmployees();

// 先按部门升序 → 再按薪资降序 → 最后按姓名升序
employees.sort(
    Comparator.comparing(Employee::getDepartment)
        .thenComparing(Comparator.comparingDouble(Employee::getSalary).reversed())
        .thenComparing(Employee::getName)
);

// Swing / JavaFX 事件处理
button.addActionListener(e -> System.out.println("clicked!"));

// CompletableFuture 异步回调
CompletableFuture.supplyAsync(() -> fetchFromDb())
    .thenApply(data -> transform(data))
    .thenAccept(result -> saveToCache(result))
    .exceptionally(ex -> { log.error("Failed", ex); return null; });

Map<String, List<Order>> grouped = new HashMap<>();

// 按客户分组（computeIfAbsent 避免 null 检查）
for (Order o : orders) {
    grouped.computeIfAbsent(o.getCustomer(), k -> new ArrayList<>())
           .add(o);
}

// merge：合并统计
Map<String, Integer> wordCount = new HashMap<>();
words.forEach(w -> wordCount.merge(w, 1, Integer::sum));

String city = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .map(String::toUpperCase)
    .orElse("UNKNOWN");