kotlin lambda表达式

先来看一个概念。

函数式接口：函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

比如java中的Runnable接口就是函数式接口。

public interface Runnable {
    public abstract void run();
}

在项目代码转为使用kotlin时，会存在和java代码互相调用的问题。不知道大家有没有注意到一个细节，kotlin构建java中的函数式接口时，可以转为lambda方式。

java方式：

Runnable runnable = new Runnable() {
    @Override
    public void run() {
    }
};

val runnable = Runnable { 
    print("runnable")
}

可以看到使用lambda表达式后，对函数式接口来讲，实现方式更加简洁。

我们都知道kotlin代码最终还是会被编译为字节码，那么kotlin中是如何实现lambda表达式的呢？

这得分两种情况：

情况1: lambda表达式内部没有持有外部的非静态变量，方法。

class Lambda{
    private var name = "小明" // 外部变量
    private fun testLambda(){
        var age = 10 // 外部变量
        val runnable = Runnable { 
            print("没有调用外部变量或方法") // 没有调用age或者name变量
        }
    }
}

查看testLambda方法编译后的字节码

// 获取静态变量 INSTANCE（该INSTANCE实际是Runnable对象的一个实现）
GETSTATIC Lambda$testLambda1$runnable$1.INSTANCE : LLambda$testLambda1$runnable$1;
// 检查 INSTANCE 是否可以转变为Runnbale对象，否则抛出异常
CHECKCAST java/lang/Runnable
// INSTANCE推入操作数栈
ASTORE 1

翻译成java代码就会类似于这样：

public class Lambda {
    private String name = "小明";

    private static Object INSTANCE = new Runnable() {
        @Override
        public void run() {
            System.out.println("没有调用外部类的成员变量");
        }
    };

    private void testLambda1() {
        Runnable runnable = (Runnable)INSTANCE;
    }
}

可以看到这种情况下lambda表达式实际上被转换为静态成员变量。

情况二：lambda表达式内部持有外部的非静态变量，方法。

class Lambda {
    private var name = "小明"
    private fun testLambda2() {
        val runnable = Runnable {
            print(name)
        }
    }
}

反编译为java代码：

 private final void testLambda2() {
      Runnable runnable = (Runnable)(new Runnable() {
         public final void run() {
            String var1 = Lambda.this.name;
            System.out.print(var1);
         }
      });
   }

可以看到lambda表达式是采用匿名内部类的方式来实现的。

那么以上两种方式有什么不同呢？

我们都知道java中匿名内部类都会隐式持有外部类的引用（即使不需要引用外部类的变量），当匿名内部类中有耗时操作时，容易造成内存泄露。

像kotlin这样的实现，在情况一的时候，lambda内部没有持有外部类的引用，不会有任何内存泄露的风险。

以上就是kotlin调用java时，lambda的实现方式。

kotlin中Functions.kt中定义了从Function0到Function22一共23个接口，每个接口有且仅有一个invoke方法，Function后边的数字代表invoke方法有几个入参，当kotlin中自定义的lambda表达式在编译的时候，会被替换为对应的接口实现。

比如：

val lambda: (() -> Unit) = {
}

由于没有参数，所以实际上会被编译为

Function0 lambda = new Function0{
    public void invoke(){
    }
}

当然了，编译规则也会像调用java中的函数式接口时一样，仅当需要持有this对象时才会编译为匿名内部类。