Java 中使用 Lambda 为什么只能使用 final 变量？-技术圈

这两天公司内部有人在讨论 Kotlin，说 Kotlin 很好用。甚至还有人说，Kotlin 会取代 Java！

太天真了，如果你说 Go 能取代 Java 我还能信，Kotlin 要是能取代 Java，Oracle 第一个不答应。虽然 Kotlin 和 Java 都寄生于 JVM，但毕竟 Java 才是亲儿子。

我个人认为 Kotlin 并不会取代 Java，而是一个以“工具人”的角色存在于 JVM 生态中。

Kotlin 没有大的抱负，仅仅定位为一套工具，它的一切特性都为实用、简洁而生。
Kotlin 不是革命者，而是改良者，它不像 Go，没有取天下而代之的野心，只有“让 Java 更好用”的踏实目标，积跬步而至千里。
Kotlin 也不完美，但在不断进步，它不像 Java 被 Oracle 一家把持，不允许任何不受控制的特性出现，Kotlin 的诞生和发展都离不开社区推动，越来越多的新特性正在应开发者呼吁加入其中。
Kotlin 不会面面俱到，而是以补 Java 的短板为先，Kotlin 不想取代任何人。

拿 Kotlin 和 Java 进行比较，其实是不公平的。Kotlin 寄生于 JVM，它其中的函数式编程使用体验好于 Java。Java 中的 Lamdba 对于参数限制为 final，而 Kotlin 则没有这个限制，究其根本原因是实现原理上的不同。

Java Lambda 表达式

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

Java Lambda 语法

(parameters) -> expression
// 或
(parameters) ->{ statements; }

以下是 lambda 表达式的重要特征:

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

Lambda 表达式实例

Lambda 表达式的简单例子：

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

使用 Lambda 表达式需要注意以下两点：

Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。
Lambda 表达式免去了使用匿名方法的麻烦，并且给予 Java 简单但是强大的函数化的编程能力。

Lambda 原理

很多人提到 Lambda 的原因，就直接说 Lambda 是靠匿名内部类实现的。这个说法不完全准确。

Lambda 表达式，有可能会生成内部类；也有可能会生成私有静态方法，还有可能生成私有方法。

具体是哪种形式，和你使用的函数式编程有关。

关于这个原理，我认为可以单独拿一篇文章来说，今天不过多讨论。

Lambda 变量作用域

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

Object instanceObj = new Object();

private void testLambda() {
    // 用于直接引用
    Object localObj1 = new Object();
    // 用于传参
    Object localObj2 = new Object();
    System.out.println(Thread.currentThread().getName());
    int num = 10;
    Consumer consumer = (x) -> {
        System.out.println(x);
        System.out.println(localObj1);
        System.out.println(instanceObj);
        System.out.println(num);
        System.out.println("consumer:" + Thread.currentThread().getName());
    };
    consumer.accept(localObj2);

}

上面代码中有一个 num 变量，并没有标记为 final。但是它却被 Lambda 表达式使用了。所以，是你说的不对？

我说的并没有错，原因是，在 Java 中：如果我声明了一个变量，且在后面不更改它的值，那么那就是事实上的 final。这种变量在 lambda 是可以使用的，但是不能被修改。

如果我们尝试修改 num 变量，发现不被允许。

如果我们不在 Lambda 中修改它，而只在 Lambda 中使用它。然后，在 Lambda 外部修改它，可能会有并发问题。正常情况下是允许的，但是在线程中是不被允许的。

public void test(){
    OpTest opTest = (x, y) -> 10 + 20 + x + y;
    int a = 10, b = 20;

    System.out.println(opTest.opTest(a, b));

    a = 0;
    b = 0;
    System.out.println("a=" + a +",b=" + b);
}

interface OpTest {
    int opTest(int a, int b);
}

输出正确的内容：

60
a=0,b=0

但是如果是下面这种情况，就不被允许。

int i = 1;
Runnable r = () -> System.out.println(i);
i = 2;

我们都知道实例变量是储存在堆上面的，是线程贡献的。而局部变量则是保存在栈上的，是线程不共享的。

java 访问局部变量的时候，实际上是去访问他的副本。如果局部变量改变了，那访问的也是之前的值。尤其是当 Lambda 是在一个线程中使用变量的，造成的数据不同步问题更加明显，因此 Lambda 有了 final 限制。

在 Java 中方法调用是值传递的，所以在 lambda 表达式中对变量的操作都是基于原变量的副本，不会影响到原变量的值。

综上，假定没有要求 lambda 表达式外部变量为 final 修饰，那么开发者会误以为外部变量的值能够在 lambda 表达式中被改变，而这实际是不可能的，所以要求外部变量为 final 是在编译期以强制手段确保用户不会在 lambda 表达式中做修改原变量值的操作。

另外，对 lambda 表达式的支持是拥抱函数式编程，而函数式编程本身不应为函数引入状态的，从这个角度看，外部变量为 final 也一定程度迎合了这一特点。