04 闭包

1 闭包

如果一个 Lambda 表达式使用了函数作用域之外的变量，会发生什么？分以下情形讨论：
（1）变量定义在类中（共享变量存储空间）。

package com.hcong.functional;

import java.util.function.IntSupplier;

/**
 * @Classname Closure1
 * @Date 2023/4/12 15:34
 * @Created by HCong
 */
public class Closure1 {
    int i;

    IntSupplier makeFun(int x) {
        return () -> x + i++;
    }

    public static void main(String[] args) {
        Closure1 c1 = new Closure1();
        System.out.println(c1.makeFun(0).getAsInt());
        System.out.println(c1.makeFun(0).getAsInt());
        System.out.println(c1.makeFun(0).getAsInt());
    }
}

0
1
2

（2）变量定义在方法中（局部变量）

class Closure2 {
    IntSupplier makeFun(int x) {
        int i = 0;
        return () -> x + i;
    }

    public static void main(String[] args) {
        Closure2 c2 = new Closure2();
        System.out.println(c2.makeFun(0).getAsInt());
        System.out.println(c2.makeFun(0).getAsInt());
        System.out.println(c2.makeFun(0).getAsInt());
    }
}

0
0
0

上述 makeFun 中的变量 i，在每次调用方法时都会重新初始化。然而，makeFun 方法中变量 x 和 i 都不能改变，即：被 Lambda 表达式引用的局部变量必须是 final 或者是等同 final 效果的，要不然会编译报错。如下：

class Closure3{
    IntSupplier makeFun(int x) {
        int i = 0;
        return () -> x++ + i++;
    }
}

即便变量 i 是包装类型，同样会编译报错：

class Closure4 {
    IntSupplier makeFun(int x) {
        Integer i = 0;
        i = i + 1;
        return () -> x + i;
    }
}

但是，对于集合类型可以通过：

class Closure5 {
    Supplier<List<Integer>> makeFun() {
        List<Integer> ai = new ArrayList<>();
        ai.add(1);
        return () -> ai;
    }

    public static void main(String[] args) {
        Closure5 c7 = new Closure5();
        List<Integer> l1 = c7.makeFun().get(), l2 = c7.makeFun().get();
        System.out.println(l1);
        System.out.println(l2);
        l1.add(42);
        l2.add(96);
        System.out.println(l1);
        System.out.println(l2);
    }
}

因为每次调用 makeFun() 时，其实都会创建并返回一个全新而非共享的 ArrayList。也就是说，每个闭包都有自己独立的 ArrayList，它们之间互不干扰。请注意我已经声明 ai 是 final 的。
（3）总结
规则并非只是在 Lambda 之外定义的任何变量必须是 final 的或等同 final 效果那么简单。相反，你必须考虑捕获的变量是否是等同 final 效果的。如果它是对象中的字段，那么它拥有独立的生存周期，并且不需要任何特殊的捕获，以便稍后在调用 Lambda 时存在。

2 作为闭包的内部类

public class AnonymousClosure {
    IntSupplier makeFun(int x) {
        int i = 0;
        return new IntSupplier() {
            public int getAsInt() {
                return x + i++;
            }
        };
    }
}

上述代码同样会编译报错，即匿名内部类需要考虑捕获的变量是否是等同 final 效果。