Java Lambda 和 Kotlin Lambda 的区别

Java 匿名内部类在编译时会创建一个 class ，增加类的加载开销，运行时该内部类无论是否用到外部参数每次都会生成该类的实例。jdk 1.8 后 lambda 的实现是在当前类增加一个私有静态方法，减少了类的开销

Kotlin 匿名内部类的实现和 Java 一致也是在编译期生成一个 class，lambda 的实现也是同样创建一个 class，但是该 class 继承 Lambda 类并实现了 Function 接口。编译时匿名内部类会转化为具体的类类型，而 lamdba 则是转化为 Function 类型传递进去

在 Kotlin 中每个 lambda 函数拥有其所对应的闭包，这个闭包就是编译后生成的 class，那么我们可以得到以下结论
1、每个 lamdba 函数都对应了一个 Function 类型的 class
2、class 的装载需要额外的资源开销

package test
class TestBean {
    fun isOpen(): Boolean {
        return true
    }
}
fun main() {
    testA(TestBean()) {
        testB()
        testC()
    }
}
fun testB() {
    println("B")
}
fun testC() {
    println("C")
}
inline fun testA(testBean: TestBean, body: () -> Unit) {
    if (testBean.isOpen()) {
        body()
    }
}

编译后的字节码为顺序调用

L2  INVOKEVIRTUAL test/TestBean.isOpen ()Z
L6  INVOKESTATIC test/Test32Kt.testB ()V
L7 INVOKESTATIC test/Test32Kt.testC ()V

去除 inline 后编译，lambda 表达式生成了一个名为 Test32Kt$main$1 的 class

L0
    LINENUMBER 12 L0
    NEW test/TestBean
    DUP
    INVOKESPECIAL test/TestBean. ()V
    GETSTATIC test/Test32Kt$main$1.INSTANCE : Ltest/Test32Kt$main$1;
    CHECKCAST kotlin/jvm/functions/Function0
    INVOKESTATIC test/Test32Kt.testA (Ltest/TestBean;Lkotlin/jvm/functions/Function0;)V

final class test/Test32Kt$main$1 extends kotlin/jvm/internal/Lambda implements kotlin/jvm/functions/Function0 {


  // access flags 0x1041
  public synthetic bridge invoke()Ljava/lang/Object;
    ALOAD 0
    INVOKEVIRTUAL test/Test32Kt$main$1.invoke ()V
    GETSTATIC kotlin/Unit.INSTANCE : Lkotlin/Unit;
    ARETURN
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x11
  public final invoke()V
   L0
    LINENUMBER 13 L0
    INVOKESTATIC test/Test32Kt.testB ()V
   L1
    LINENUMBER 14 L1
    INVOKESTATIC test/Test32Kt.testC ()V
   L2
    LINENUMBER 15 L2
    RETURN
   L3
    LOCALVARIABLE this Ltest/Test32Kt$main$1; L0 L3 0
    MAXSTACK = 0
    MAXLOCALS = 1

  // access flags 0x0
  ()V
    ALOAD 0
    ICONST_0
    INVOKESPECIAL kotlin/jvm/internal/Lambda. (I)V
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x19
  public final static Ltest/Test32Kt$main$1; INSTANCE

  // access flags 0x8
  static ()V
    NEW test/Test32Kt$main$1
    DUP
    INVOKESPECIAL test/Test32Kt$main$1. ()V
    PUTSTATIC test/Test32Kt$main$1.INSTANCE : Ltest/Test32Kt$main$1;
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 0

}

在 Test32Kt$main$1 class 中 invoke 方法内调用了 testB() 和 testC()，这也恰恰说明了为何函数类型的实例可以通过 xxx() 来调用方法，因为 () 相当于调用了该函数的 invoke
由此可见，在没有函数内联修饰的情况下，Java 的 lamdba 执行效率是高于 kotlin 的，因为它减少了类的开销。
那是不是可以把每个方法都进行内联修饰呢，答案是不能，因为内联的预期性能影响是微不足道的，内联最适用于具有函数类型参数的函数。

方法内联的意思是在编译期对函数进行优化，以达到提高代码执行效率的作用。
方法内联一般出现在两个地方
1、class 编译期-》javac 编译期把代码编译成 class 对函数进行内联处理
2、JVM 运行期-》JIT（Just-in-time）即动态编译器，在编译时会把热点代码先预编译为机器码，其他代码在运行时逐行解释运行；AOT （Ahead of time） 即静态编译器，在编译时会预先把 class 全部编译为机器码