kotlin—lambda及其原理

1、lambda简介

lambda表达式是函数字面词，首先它是一个表达式，此表达式的结果是返回一个函数而且函数是未实现声明的，可以理解为lambda表达式声明了一个函数同时将此函数作为表达式的结果返回给调用者。
lambda表达在kotlin中广泛使用，因为其使用简单明了。

2、lambda语法

lambda表达式的完整语法如下：

val 变量 : ([参数类型列表]) -> 返回类型 = { [参数名: 参数类型[, 参数列表.....]] -> 方法体 }

等号后面花括号{}的内容就是lambda表达式，语法规则可以总结如下：

• lambda表达式是总是由花括号{}包裹
• lambda表达式声明的函数参数列表在 -> 前面，与普通函数参数声明方式一样，但：
  • 参数列表不能用括号()包裹
  • 没有任何参数时，则不需要括号和->
  • 只有一个参数时，则可以省略参数使用默认的it代替，同时省略->
• lambda表达式声明的函数体在 -> 后面
• lambda表达式声明的函数的返回值不是Unit，则最后一个表达式作为函数的返回值，如果

2.1 拖尾lambda表达式

拖尾lambda表达式就是如果函数的最后一个参数是函数类型，那么作为以lambda表达式函数参数可以提放到括号()之外：

val sum = items.sum(1) { a, b -> a + b }

其等价于：

val sum = items.sum(1, {a, b -> a + b})

如果lambda表达式是函数的唯一一个参数，则函数的参数及括号可以省略，如下所示：

val sum = items.sum { a, b -> a + b }

其等价于：

val sum = items.sum({a, b -> a + b})

2.2 lambda表达式隐匿的参数it

如果lambda表达式的函数参数列表只有一个，则可以省略函数参数列表，该参数使用隐匿的it表示，如下所示：

val sum = items.sum { it + 1 }

其等价于：

val sum = items.sum {it -> it + 1}

2.3 lambda表达式返回值

lambda表达式中的函数体中的最后一个表达式默认作为lambda表达式的返回值，也可以显示返回一个值：

val sum: (Int, Int) -> Int = { a, b ->
        a + b
    }

等价于:

val sum: (Int, Int) -> Int = tag@{ a, b ->
        return@tag a + b
    }

3、lambda原理

上面介绍了lambda表达式的语法、规则，那么lambda的实现原理是什么呢？
我们通过一个简单的例子剖析其原理:

class TestFun {
    val sum: (Int, Int) -> Int = { a, b ->
        a + b
    }

    fun main() {
        sum(1, 2)
    }
}

编译之后的字节码文件之后，会发现除了生成TestFun.class文件文件之外，还生成了一个匿名类TestFun1，其实它是lambda表达式转成的一个匿名类，我们使用javac -c -v -p xxx.class反编译TestFun1得到的伪代码为：

//TestFun$sum$1继承Lambda 类，同时实现Function2接口
final class com.wyx.tcanvas.test.delegate.TestFun$sum$1 extends kotlin.jvm.internal.Lambda implements kotlin.jvm.functions.Function2<java.lang.Integer, java.lang.Integer, java.lang.Integer>
  //省略......
{
  //定义TestFun$sum$1的单例对象
  public static final com.wyx.tcanvas.test.delegate.TestFun$sum$1 INSTANCE;
    descriptor: Lcom/wyx/tcanvas/test/delegate/TestFun$sum$1;
    flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL
  //构造函数
  com.wyx.tcanvas.test.delegate.TestFun$sum$1();
    descriptor: ()V
    flags: (0x0000)
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: iconst_2
         //调用父类lambda的init方法
         2: invokespecial #12                 // Method kotlin/jvm/internal/Lambda."<init>":(I)V
         5: return
       //省略......
  
  //lambda表达函数体生成的对应函数invoke，invode函数的内容就是lambda的函数体内容
  public final java.lang.Integer invoke(int, int);
    descriptor: (II)Ljava/lang/Integer;
    flags: (0x0011) ACC_PUBLIC, ACC_FINAL
    Code:
      stack=2, locals=3, args_size=3
         0: iload_1 //加载第2个局部变量即函数参数的第1个变量a,到栈顶
         1: iload_2 //加载第3个局部变量即函数参数的第2个变量b
         2: iadd //对栈顶两个元素进行正式相加
         //将相加结果转为Integer类型，并放到栈顶
         3: invokestatic  #23                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
         6: areturn //返回栈顶即相加的结果
      //省略......
  
  //实现Function2接口的invoke方法
  public java.lang.Object invoke(java.lang.Object, java.lang.Object);
    descriptor: (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
    flags: (0x1041) ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC
    Code:
      stack=3, locals=3, args_size=3
         0: aload_0
         1: aload_1
         //校验函数第1个参数是否为Number类型
         2: checkcast     #29                 // class java/lang/Number
          //将函数第1个参数转为Integer类型
         5: invokevirtual #33                 // Method java/lang/Number.intValue:()I
         8: aload_2
         //校验函数第2个参数是否为Number类型
         9: checkcast     #29                 // class java/lang/Number
        //将函数第2个参数转为Integer类型
        12: invokevirtual #33                 // Method java/lang/Number.intValue:()I
        //调用上面的成员方法invoke方法，参数分别对应此函数的参数，将结果放到栈顶
        15: invokevirtual #35                 // Method invoke:(II)Ljava/lang/Integer;
        18: areturn //返回栈顶的值
       //省略......
  
  //匿名类的静态语句块，
  static {};
     //省略......
      //创建TestFun$sum$1的实例对象
         0: new           #2                  // class com/wyx/tcanvas/test/delegate/TestFun$sum$1
         3: dup
          //调用TestFun$sum$1的实例对象的init方法
         4: invokespecial #41                 // Method "<init>":()V
          //将创建的TestFun$sum$1的实例对象赋值给单例对象INSTANCE
         7: putstatic     #44                 // Field INSTANCE:Lcom/wyx/tcanvas/test/delegate/TestFun$sum$1;
        10: return
}
 //省略......

我们看到lambda表达式编译之后会通过生成一个匿名类来实现，匿名类继承Lambda类同时实现Function接口（根据lambda表达式函数参数个数实现对应的Function1/Function2....），匿名类内部在类加载时创建它的一个公有单例（供外部通过此单例调用成员方法），匿名类同时有两个invoke方法，一个将lambda表达式转为函数，一个是实现了Function接口的invoke函数，Function接口的invoke函数内部调用lambda表达式转成的函数invoke。

4、总结

lambda表达式其实是通过生成一个匿名类实现，它继承Lambda类同时实现Function接口（此Function接口根据lambda表达式函数的个数选择不同的Function系列接口，比如只有一个参数，则实现Function1接口，依次类推）。使用是调用Function的invoke方法，Function的invoke方法转而去调用匿名类生成的与lambda表达式对应的方法invoke。
lambda表达式不一定实现的是Function接口，它会根据所处的上下文环境实现响应的接口，比如用lambda表达式代替一个callback，则它实现的就不是Function接口了而是callback。
如果lambda仅仅用作一个匿名函数，其实是大财所用了，因为它会额外的生成一个匿名类，使用时使用此匿名类的单例调用对应的函数，不仅增加一个类而且还需要在时候的是创建它的一个单例对象而且还需要两次的函数调用，不仅增加了空间还损耗了运行时间，所以lambda仅仅用作一个匿名函数是不明智的选择，此场景建议使用一个真实的具名成员函数较好。
lambda用在类似callback、方法参数较为合适，因为反正都需要生成一个匿名类，所以性能是差不多的。