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 也一定程度迎合了这一特点。
