四、Lambda复杂场景用法：深入函数式编程核心

除了常见场景，Lambda在复杂业务逻辑中也能发挥作用，如闭包与变量捕获、方法引用结合、自定义函数式接口、异步编程等。这些用法需要对函数式接口和Lambda的本质有更深入的理解。

4.1 闭包与变量捕获：Lambda访问外部变量的规则

Lambda表达式可以访问外部变量（定义在Lambda之外的变量），这种特性称为“闭包”。但Java对外部变量有严格限制：外部变量必须是final或“ effectively final”（实际不可变）。

4.1.1 什么是“effectively final”？

若变量声明时未加final，但后续代码中从未修改过其引用（对于对象）或从未重新赋值（对于基本类型），则该变量是“effectively final”，Lambda可访问。

样例：Lambda访问外部变量

public class LambdaClosureDemo {
    public static void main(String[] args) {
        // 1. 基本类型外部变量（effectively final：未修改）
        int base = 10; // 未重新赋值，effectively final
        Function<Integer, Integer> addBase = num -> num + base;
        System.out.println("15 + " + base + " = " + addBase.apply(15)); // 输出：15 + 10 = 25

        // 错误：若修改base，编译报错（base不再是effectively final）
        // base = 20; // 编译报错：Local variable base defined in an enclosing scope must be final or effectively final

        // 2. 对象类型外部变量（effectively final：引用未修改）
        User user = new User("张三", 25); // 引用未修改，effectively final
        Consumer<String> updateName = newName -> user.setName(newName); // 修改对象属性（允许）
        updateName.accept("张三三");
        System.out.println("修改后姓名：" + user.getName()); // 输出：修改后姓名：张三三

        // 错误：若修改user引用，编译报错
        // user = new User("李四", 30); // 编译报错：引用被修改，不再是effectively final

        // 3. 成员变量（无final限制）
        LambdaClosureDemo demo = new LambdaClosureDemo();
        demo.memberVar = 5;
        Function<Integer, Integer> addMemberVar = num -> num + demo.memberVar;
        System.out.println("10 + " + demo.memberVar + " = " + addMemberVar.apply(10)); // 输出：10 + 5 = 15
        // 成员变量可修改（Lambda访问的是最新值）
        demo.memberVar = 8;
        System.out.println("10 + " + demo.memberVar + " = " + addMemberVar.apply(10)); // 输出：10 + 8 = 18
    }

    // 成员变量（Lambda访问成员变量无final限制）
    private int memberVar;
}

4.1.2 为什么外部变量必须是final或effectively final？

Lambda表达式可能在另一个线程中执行（如异步任务），而外部变量若可修改，会导致“线程安全问题”。Java通过限制变量不可变，避免了这种风险。

4.2 方法引用：Lambda的“语法糖”

当Lambda的代码主体仅为“调用一个已存在的方法”时，可通过“方法引用”进一步简化语法。方法引用本质是Lambda的简写形式，其语法为类名::方法名或对象::方法名。

4.2.1 方法引用的4种类型

类型	语法格式	对应的Lambda表达式	样例
静态方法引用	类名::静态方法名	(参数) -> 类名.静态方法名(参数)	Integer::parseInt → s -> Integer.parseInt(s)
实例方法引用（对象）	对象::实例方法名	(参数) -> 对象.实例方法名(参数)	System.out::println → s -> System.out.println(s)
实例方法引用（类）	类名::实例方法名	(对象, 参数) -> 对象.实例方法名(参数)	String::compareTo → (s1, s2) -> s1.compareTo(s2)
构造方法引用	类名::new	(参数) -> new 类名(参数)	User::new → (name, age) -> new User(name, age)

样例：4种方法引用的使用

import java.util.Arrays;
import java.util.List;
import java.util.function.*;

public class MethodReferenceDemo {
    public static void main(String[] args) {
        // 1. 静态方法引用：类名::静态方法名
        // Lambda：(s) -> Integer.parseInt(s)
        Function<String, Integer> strToInt = Integer::parseInt;
        System.out.println("字符串'123'转整数：" + strToInt.apply("123")); // 输出：123

        // 2. 实例方法引用（对象）：对象::实例方法名
        // Lambda：(s) -> System.out.println(s)
        Consumer<String> printer = System.out::println;
        printer.accept("实例方法引用（对象）演示"); // 输出：实例方法引用（对象）演示

        // 3. 实例方法引用（类）：类名::实例方法名
        // Lambda：(s1, s2) -> s1.compareTo(s2)
        Comparator<String> strComparator = String::compareTo;
        int compareResult = strComparator.compare("Apple", "Banana");
        System.out.println("Apple vs Banana 比较结果：" + compareResult); // 输出：-1（Apple < Banana）

        // 4. 构造方法引用：类名::new
        // Lambda：(name, age) -> new User(name, age)
        BiFunction<String, Integer, User> userCreator = User::new;
        User user = userCreator.apply("李四", 30);
        System.out.println("构造方法引用创建用户：" + user); // 输出：User(name=李四, age=30)

        // 进阶：Stream中使用方法引用
        List<String> strList = Arrays.asList("1", "2", "3", "4");
        // 静态方法引用：将String转为Integer
        List<Integer> intList = strList.stream()
                .map(Integer::parseInt) // 等价于 s -> Integer.parseInt(s)
                .collect(java.util.stream.Collectors.toList());
        System.out.println("字符串列表转整数列表：" + intList); // 输出：[1, 2, 3, 4]
    }
}

4.3 自定义函数式接口：应对复杂业务场景

Java内置的函数式接口覆盖了大多数场景，但当业务需要“多参数”“特殊返回值”时，需自定义函数式接口。例如：处理3个参数并返回结果，或抛出checked异常的函数。

样例1：自定义“三参数函数式接口”

需求：定义一个接口，接收String、Integer、Boolean三个参数，返回User对象：

// 自定义三参数函数式接口
@FunctionalInterface
public interface TriFunction<T1, T2, T3, R> {
    R apply(T1 t1, T2 t2, T3 t3);
}

// 使用自定义接口
public class CustomTriFunctionDemo {
    public static void main(String[] args) {
        // Lambda实现TriFunction：根据姓名、年龄、是否VIP创建User
        TriFunction<String, Integer, Boolean, User> userCreator = (name, age, isVip) -> {
            User user = new User(name, age);
            if (isVip) {
                user.setName(user.getName() + "(VIP)"); // VIP用户姓名加标识
            }
            return user;
        };

        // 调用apply方法创建用户
        User vipUser = userCreator.apply("张三", 25, true);
        User normalUser = userCreator.apply("李四", 30, false);

        System.out.println(vipUser); // 输出：User(name=张三(VIP), age=25)
        System.out.println(normalUser); // 输出：User(name=李四, age=30)
    }
}

样例2：自定义“抛出异常的函数式接口”

Java内置函数式接口的抽象方法不抛出checked异常，若业务需要抛出异常（如IO操作、数据库操作），需自定义带异常声明的函数式接口：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

// 自定义带checked异常的函数式接口
@FunctionalInterface
public interface ThrowingFunction<T, R, E extends Exception> {
    R apply(T t) throws E;
}

// 使用自定义接口（处理文件读取，可能抛出FileNotFoundException）
public class ThrowingFunctionDemo {
    public static void main(String[] args) {
        // Lambda实现：读取文件内容（可能抛出FileNotFoundException）
        ThrowingFunction<String, String, FileNotFoundException> fileReader = filePath -> {
            File file = new File(filePath);
            Scanner scanner = new Scanner(file); // 可能抛出FileNotFoundException
            StringBuilder content = new StringBuilder();
            while (scanner.hasNextLine()) {
                content.append(scanner.nextLine()).append("\n");
            }
            scanner.close();
            return content.toString();
        };

        // 调用带异常的Lambda（必须捕获或声明异常）
        try {
            String content = fileReader.apply("D:/test.txt");
            System.out.println("文件内容：" + content);
        } catch (FileNotFoundException e) {
            System.err.println("文件未找到：" + e.getMessage());
        }
    }
}

4.4 Lambda与CompletableFuture：异步编程

CompletableFuture是Java 8引入的“异步编程工具”，支持链式调用和异步结果处理，其核心方法（如supplyAsync、thenApply、thenAccept）均接收Lambda表达式，是实现“非阻塞异步任务”的最佳实践。

样例：异步执行任务并处理结果

需求：异步查询用户信息，查询完成后异步更新用户积分，最后输出结果：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 模拟用户服务
class UserService {
    // 模拟异步查询用户（耗时操作）
    public CompletableFuture<User> queryUserAsync(String userId) {
        // supplyAsync：异步执行有返回值的任务
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("查询用户线程：" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000); // 模拟耗时查询
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return new User("张三", 25); // 模拟查询结果
        });
    }

    // 模拟异步更新用户积分（耗时操作）
    public CompletableFuture<User> updatePointsAsync(User user, int points) {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("更新积分线程：" + Thread.currentThread().getName());
            try {
                Thread.sleep(800); // 模拟耗时更新
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            user.setAge(user.getAge() + 1); // 模拟更新积分（此处用年龄代替）
            return user;
        });
    }
}

public class CompletableFutureLambdaDemo {
    public static void main(String[] args) {
        // 自定义线程池（避免使用默认ForkJoinPool，推荐实际开发使用）
        ExecutorService executor = Executors.newFixedThreadPool(2);
        UserService userService = new UserService();

        // 异步流程：查询用户 → 更新积分 → 处理结果
        CompletableFuture<Void> asyncFlow = userService.queryUserAsync("1")
                // thenCompose：将前一个CompletableFuture的结果作为参数，返回新的CompletableFuture（异步链式调用）
                .thenCompose(user -> userService.updatePointsAsync(user, 100))
                // thenAccept：处理最终结果（无返回值）
                .thenAccept(user -> {
                    System.out.println("最终处理线程：" + Thread.currentThread().getName());
                    System.out.println("处理完成的用户：" + user);
                })
                // exceptionally：处理整个流程中的异常
                .exceptionally(ex -> {
                    System.err.println("异步流程异常：" + ex.getMessage());
                    return null;
                });

        // 等待异步流程完成（避免主线程提前退出）
        asyncFlow.join();

        // 关闭线程池
        executor.shutdown();
    }
}

输出结果（线程名可能不同）：

查询用户线程：pool-1-thread-1
更新积分线程：pool-1-thread-2
最终处理线程：pool-1-thread-2
处理完成的用户：User(name=张三, age=26)

关键说明：

• supplyAsync：异步执行有返回值的任务，适合耗时操作（如查询数据库、调用远程接口）；
• thenCompose：用于“异步任务的链式调用”，避免嵌套CompletableFuture（即“扁平化”）；
• thenAccept：处理最终结果（无返回值），适合消费数据；
• exceptionally：捕获整个异步流程中的异常，避免异常被忽略；
• 自定义线程池：CompletableFuture默认使用ForkJoinPool.commonPool()，实际开发中建议自定义线程池，避免线程资源竞争。