智能备课系统

1. 为什么lambda 表达式中使用的变量应为 final 或有效 final

Lambda 表达式本质上类似于匿名内部类，而 Java 的匿名内部类访问外部变量时，只能访问常量（即 final 变量），而不是可变变量。这是因为 Lambda 可能会在原始作用域之外执行，而 Java 变量的作用域在方法调用结束后就会消失，防止 Lambda 访问已被销毁的变量。

2. 示例：Lambda 与匿名内部类的对比

public class Test {
    public static void main(String[] args) {
        int num = 100;

        // Lambda 表达式
        Runnable r1 = () -> System.out.println(num);
        
        // 匿名内部类
        Runnable r2 = new Runnable() {
            @Override
            public void run() {
                System.out.println(num);
            }
        };

        r1.run();
        r2.run();
    }
}

在 Runnable 的 run 方法中，Lambda 和匿名内部类都可以使用 num，但 num 不能在 main 方法中被修改，否则会导致编译错误。

Lambda 表达式可能会在原始作用域之外执行的典型场景之一是 多线程（如 Thread 或 ExecutorService），因为 Lambda 可能会在方法返回后仍然被异步执行。

3. 示例：Lambda 在原始作用域之外执行

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

public class LambdaScopeExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        int num = 10; // effectively final

        executor.submit(() -> {
            // 这里的 Lambda 可能在 main 方法结束后才执行
            System.out.println("Lambda 输出: " + num);
        });

        executor.shutdown(); // 关闭线程池
        System.out.println("主线程结束");
    }
}

4. 为什么这个 Lambda 可能会在原始作用域之外执行？

1. executor.submit() 提交了一个 Lambda 任务，它会在后台线程中执行。
2. main() 方法可能已经执行完毕，但 Lambda 仍然可能在另一个线程中运行。
3. 如果 num 变量可以修改，可能会导致数据不一致的问题，因此 Java 规定 Lambda 只能访问 final 或 effectively final 变量。

5. 如果变量不是 effectively final，会怎样？

如果我们尝试在 Lambda 外部修改 num：

public class LambdaScopeExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        int num = 10; // 不是 effectively final
        executor.submit(() -> System.out.println("Lambda 输出: " + num));

        num = 20; // ❌ 编译错误：变量 num 必须是 effectively final

        executor.shutdown();
    }
}

上面代码会报错，因为 num 变量在赋值后又被修改了（num = 20;），它不再是 effectively final，所以 Lambda 无法捕获它。

4. 如何解决这个问题？

如果想在 Lambda 里使用可变变量，可以改用 数组 或 对象：

public class LambdaMutableExample {
    public static void main(String[] args) {
        final int[] num = {10}; // 使用数组
        Runnable r = () -> {
            num[0] += 10; // 允许修改
            System.out.println(num[0]);
        };
        r.run();
    }
}

或者使用 **AtomicInteger**：

import java.util.concurrent.atomic.AtomicInteger;

public class LambdaAtomicExample {
    public static void main(String[] args) {
        AtomicInteger num = new AtomicInteger(10);
        Runnable r = () -> {
            num.incrementAndGet(); // 线程安全
            System.out.println(num.get());
        };
        r.run();
    }
}

总结

• Lambda 表达式中的变量必须是 final 或 effectively final（赋值后未修改）。
• 这是因为 Lambda 本质上类似于匿名内部类，不能捕获非 final 变量。
• 如果需要修改变量，可以使用数组、对象或者Atomic 变量来解决。