java final 函数_Java8 中 Lambda函数的 Effectively final 特性——从阶乘说起

在某乎看到一个提问，怎样用Lambda写阶乘？

由于Java的 Effectively final 特性，以下代码无法通过编译。

Function factorial = null;

factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);

有位答主提供了一个方案：在构造函数中初始化：

public class Factorial {

Function factorial = null;

public Factorial() {

factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);

}

public static void main(String[] args) {

System.out.println(new Factorial().factorial.apply(5));

}

}

看起来和错误写法差不多，但居然是可用的！但是答主并不知道原理，解释为可能是构造函数的特殊性。

仅仅是因为构造函数吗？我试了下在构造代码块中，在普通函数中，都可以正确初始化。似乎只要lambda函数是类变量就可以。

public class Factorial {

Function factorial = null;

// 构造代码块中初始化

{

factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);

}

// 普通函数初始化

// public Function set() {

// factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);

// return factorial;

// }

public static void main(String[] args) {

System.out.println(new Factorial().factorial.apply(5));

// System.out.println(new Factorial().set().apply(10));

}

}

甚至把lambda定义为static，在static块中初始化，也能通过编译。

但是这是为什么呢？

为什么Java要求 Lambda 函数中使用的外部变量必须是 Effectively final？

可以看这篇回答，虽然讲的是匿名内部类，但是原理相通。

简单来讲就是：Java支持了有限的闭包，在编译时给匿名内部类增加了个构造函数，把外部的局部变量复制了一份到内部类里。

用匿名内部类写这样一份测试代码：

public class Func{

public static void main(String[] args){

Integer a = 10, b = 20;

Runnable runnable = new Runnable() {

@Override

public void run(){

System.out.println(a + b);

}

};

runnable.run();

}

}

反编译后的结果：

// Func.class，把两个局部变量写为 final

public static void main(String[] var0) {

final Integer var1 = 10;

final Integer var2 = 20;

Runnable var3 = new Runnable() {

public void run() {

System.out.println(var1 + var2);

}

};

var3.run();

}

// Func$1.class，通过构造函数传入了局部变量

final class Func$1 implements Runnable {

Func$1(Integer var1, Integer var2) {

this.val$a = var1;

this.val$b = var2;

}

public void run() {

System.out.println(this.val$a + this.val$b);

}

}

通过偷偷塞构造函数的方式，传入了局部变量的一个拷贝。

如果允许修改该局部变量的引用，外部修改无法对内部生效，内部的修改也无法对外部生效，一定程度上会引起歧义，索性写死为final得了。

其他语言是怎么做的？

但是同为JVM语言的Scala，似乎并没有这种限制。

// Scala源码,Lambda 函数中修改number的值，且生效

def tryAccessingLocalVariable{

var number = 1

println(number)

var lambda = () => {

number = 2

println(number)

}

lambda.apply()

println(number)

}

// 编译后，用 IntRef 包装了 number

public final class TryUsingAnonymousClassInScala$$anonfun$1 extends AbstractFunction0.mcV.sp

implements Serializable{

public static final long serialVersionUID = 0L;

private final IntRef number$2;

public final void apply(){

apply$mcV$sp();

}

public void apply$mcV$sp() {

this.number$2.elem = 2;

Predef..MODULE$.println(BoxesRunTime.boxToInteger(this.number$2.elem));

}

public TryUsingAnonymousClassInScala$$anonfun$1(TryUsingAnonymousClassInScala $outer, IntRef number$2) {

this.number$2 = number$2;

}

}

Scala是通过 IntRef 包装以后传入的，修改时通过IntRef.elem = 2;的方式，并未修改IntRef的引用，实际IntRef还是final的。

手动绕过外部变量不允许修改的限制

和Scala类似，在Java里，我们给变量加个包装即可，只不过需要手动添加。据说JDK里有很多代码就是这样干的。

int a[] = {0};

Runnable runnable = () -> a[0]++;

匿名函数/Lambda函数对类变量的处理

匿名函数和Lambda函数在这方面有相似的特性，所以把最开始那个阶乘代码写成匿名函数的方式并反编译(Lambda反编译看不到细节)：

// 源码

public class Factorial{

static Function factorial = null;

static {

factorial = new Function() {

@Override

public Integer apply(Integer i){

return i == 0 ? 1 : i * factorial.apply(i - 1);

}

};

}

public static void main(String[] args){

System.out.println(Factorial.factorial.apply(10));

}

}

// 匿名函数反编译后的类

class Factorial$1 implements Function{

Factorial$1(Factorial var1) {

this.this$0 = var1;

}

public Integer apply(Integer var1){

return var1 == 0 ? 1 : var1 * (Integer)Factorial.factorial.apply(var1 - 1);

}

}

编译器在匿名类的构造函数里把外部对象给传了进来，和内部类非常相似。

所以明显的，在这种情况下，看起来似乎绕过了 Effectively final 特性，实际是匿名函数/Lambda函数持有了外部对象的引用！

为什么JDK要用如此别扭的方式，而不是像Scala那样支持完整的闭包？

openJDK给出的回答是，类似Scala这种处理方式，在多线程下会有问题。相比它的好处，它带来的问题似乎更严重。

最初问题的答案

只需要让Lambda函数编译生成的类传入外部对象的引用，即可达到“看起来绕过Effectively final特性”的效果。

Lamabda 阶乘的另一种写法

由于数组也是特殊的对象，所以还可以这样写：

Function[] funcs = new Function [1];

funcs[0] = i -> i == 0 ? 1 : i * funcs[0].apply(i - 1);

System.out.println(funcs[0].apply(5));

更简单直观。