Kotlin第八讲---Lambda表达式

最新推荐文章于 2022-12-28 11:05:59 发布

奇舞移动

最新推荐文章于 2022-12-28 11:05:59 发布

阅读量318

点赞数

本文链接：https://blog.csdn.net/QiwooMobile/article/details/102577850

版权

内容简介

上一篇我们讲解了函数定义丶特点丶实现原理。这一篇我们主讲一下 Kotlin 中的 Lambda 表达式和它的本质。Lambda 早在 Java 中就存在了，但是我们一般都视而不见。Kotlin 中 Lambda 表达式扮演着很重要的角色，所以必须搞明白哦！

定义Lambda表达

定义一个 Lambda 表达式，主要使用 {} 来定义，下方的代码是定义一个再简单不过的 Lambda 表达式了。


   
   /**
 * 定义一个 Lambda 并将其赋值给一个变量
 * 无参的
 */
val lambda = {}
fun main() {
 /**
 * 调用定义的 Lambda 表达式
 * 通过 () 调用或调用 invoke 方法
 */
 lambda()
 lambda.invoke()
}

定义有参Lambda表达式

其实定义有参的 Lambda 只需要通过 {参数1:类型,参数2:类型->} 定义即可（特别注意有一个 -> 小箭头哦）。


   
   /**
 * 定义一个 Lambda 并将其赋值给一个变量
 * 有参的 lambda 表达式
 */
val lambda = { name: String, age: Int ->
 println("$name $age")
}
fun main() {
 /**
 * 调用定义的 Lambda 表达式
 * 通过 () 调用或调用 invoke 方法
 * 传参
 */
 lambda("阿文",18)
 lambda.invoke("awen",18)
}

定义具有返回值的Lambda表达式

Lambda 表达式的返回值和一般函数不一样，一般函数是通过 return 来确定。而 Lambda 表达式是最后一句代码的返回值来确定（注意：只有 Lambda 才有此功能，普通函数乖乖的写 return 吧）。


   
   /**
 * 定义一个具有返回值的 Lambda 表达式
 */
val sum = { v1: Int, v2: Int ->
 v1 + v2
}
fun main() {
 val value = sum(1, 2)
 println("1 + 2 = $value")
}

这里补充一点：若我们的 Lambda 表达式最后一句代码的返回值，不是表达式要返回的或本身表达式没有返回值，要如何处理呢？其实我们只需要在 Lambda 表达式末尾，写入要返回的变量即可。


   
   val call = { v1: Int, v2: Int ->
 v1 + v2
 // 最后一句代码返回 Unit 变量，代表没有返回值
 Unit
}
fun main() {
 call(1, 2)
}

Lambda使用

在上一章中，我们提到过一个很重要的特性，在 Kotlin 中可以将函数以参数的形式传递，还记得为何能传递吗？

因为传递函数的本质是传递了一个实现 FunctionN 接口的一个对象。细心的同学也许注意到了，我们定义的 Lambda 表达式都存放到了一个变量当中，既然能存在变量当中，那么 Lambda 表达式肯定也可以来回传递的。


   
   /**
 * 我们用Android 中最常见的回调来举例
 *
 * 定义成功的 lambda 表达式
 */
val success = { success: String ->
 println(success)
}
/**
 * 定义出错的 lambda 表达式
 */
val error = { error: String ->
 println(error)
}
/**
 * 定义调用方法
 */
fun call(success: (String) -> Unit, error: (String) -> Unit) {
 if (Random(20).nextInt() % 2 == 0) {
 success("成功")
 } else {
 error("出错")
 }
}
fun main() {
 // 调用并传入2个 Lambda 表达式
 call(success, error)
}

上面的代码，我将 2 个 Lambda 表达式以参数的形式传递给了 call 函数。其实一般我们不这样定义，还记得我讲过 Kotlin 中可以支持函数嵌套吗（大家可以回顾下原理）？
我们一般这样写：


   
   /**
 * 定义调用方法
 */
fun call(success: (String) -> Unit, error: (String) -> Unit) {
 if (Random(20).nextInt() % 2 == 0) {
 success("成功")
 } else {
 error("出错")
 }
}
fun main() {
 // 调用并传入2个 Lambda 表达式
 call({
 println(it)
 }, { error ->
 println(error)
 })
}

看到这里，大家应该注意2个问题。

调用的时候 call 方法的时候，嵌套定义的 Lambda 表达式，怎么没定义变量， it 又是个什么东西？
call 方法定义的行参中的类型 (String)->Unit 是啥意思？上一章节中传递函数类型使用的不是 FunctionN 类型吗？

这里我解释下第一个问题，函数只需要一个参数的 Lambda 表达式的时候，定义的 Lambda 可以不写这个参数（当然你想写也可以，例如我的 error ），第一个参数用 it来代替。

至于第二个问题，请看下一小节。

通过本质看Lambda

上一篇中，我们讲过函数当做参数传递，本质是传递了一个实现 FunctionN 的对象，那 Lambda 和 FunctionN 有什么关系呢？以及我们前面举例的 (String)->Unit 到底是什么？
我们来看下下面的代码：


   
   /**
 * 定义调用方法
 * 注意我将 success & error Function1对象
 */
fun call(success: Function1<String, Unit>, error: Function1<String, Unit>) {
 if (Random(20).nextInt() % 2 == 0) {
 success("成功")
 } else {
 error("出错")
 }
}
fun main() {
 // 调用并传入2个 Lambda 表达式
 call({
 println(it)
 }, { error ->
 println(error)
 })
}

是不是发现了什么？类型是 FunctionN 的对象，可以直接定义对应参数个数和返回值的 Lambda 即可。那是不是说定义的 Lambda 表达式最终会编译成一个实现 FunctionN 的接口对象呢（和上一篇中的函数指针类似）？
我们来看下反编译结果：


   
   public final class DemoKt {
 public static final void call(@NotNull Function1<? super String, Unit> success, @NotNull Function1<? super String, Unit> error) {
 ...
 if (RandomKt.Random(20).nextInt() % 2 == 0) {
 success.invoke("成功");
 } else {
 error.invoke(“出错”);
 }
 }
 public static final void main() {
 // 可以看到定义的 Lambda 表达式，最终生成了2个类 DemoKt$main$1 和 DemoKt$main$2
 call(DemoKt$main$1.INSTANCE, DemoKt$main$2.INSTANCE);
 }
}

可以看到定义的 Lambda 表达式，最终生成了2个类 DemoKt$main$1 和 DemoKt$main$2，我们看下 DemoKt$main$1 的源码，果然没错的确是实现了 Function1 接口。


   
   final class DemoKt$main$1 extends Lambda implements Function1<String, Unit> {
 public static final DemoKt$main$1 INSTANCE = new DemoKt$main$1();
 DemoKt$main$1() {
 super(1);
 }
 public /* bridge */ /* synthetic */ Object invoke(Object obj) {
 invoke((String) obj);
 return Unit.INSTANCE;
 }
 public final void invoke(@NotNull String it) {
 System.out.println(it);
 }
}

到现在我们明白了 Lambda 表达式最终会编译成实现 FunctionN 的类。接下来我们去看下 FunctionN 接口的定义。


   
   /** A function that takes 0 arguments. */
public interface Function0<out R> : Function<R> {
 /** Invokes the function. */
 public operator fun invoke(): R
}
/** A function that takes 1 argument. */
public interface Function1<in P1, out R> : Function<R> {
 /** Invokes the function with the specified argument. */
 public operator fun invoke(p1: P1): R
}
..... 中间还有多 Function0 到 Function22
/** A function that takes 22 arguments. */
public interface Function22<in P1, in P2, in P3, in P4, in P5, in P6, in P7, in P8, in P9, in P10, in P11, in P12, in P13, in P14, in P15, in P16, in P17, in P18, in P19, in P20, in P21, in P22, out R> : Function<R> {
 /** Invokes the function with the specified arguments. */
 public operator fun invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18, p19: P19, p20: P20, p21: P21, p22: P22): R
}

我们可以看到定义了超级多的 FunctionN 的接口，对应 N 代表的是有多少个参数，也就是说定义的 Lambda 表达式最多支持 22 个参数，接下来验证下超过 23 个 Lambda 表达式会怎样呢？经过我测试执行下方代码正常，我很诧异，为啥？不是只定义到了 Function22 吗？


   
   /**
 * 定义超过23个参数的lambda表达式
 */
val test =
 { va1: Int, va2: Int, va3: Int, va4: Int, va5: Int, va6: Int, va7: Int,
 va8: Int, va9: Int, va10: Int, va11: Int, va12: Int, va13: Int, va14:
 Int, va15: Int, va16: Int, va17: Int, va18: Int, va19: Int, va20: Int,
 va21: Int, va22: Int, va23: Int ->
 }
fun main() {
 // 测试调用
 test(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23)
}

看下源码，发现既然还真有一个 FunctionN 的接口存在


   
   final class DemoKt$test$1 extends Lambda implements FunctionN<Unit> {
 public static final DemoKt$test$1 INSTANCE = new DemoKt$test$1();
 DemoKt$test$1() {
 super(23);
 }
 public Object invoke(Object[] objArr) {
 Object[] objArr2 = objArr;
 if (objArr2.length != 23) {
 // 如果数组的长度不是23个就报错
 Intrinsics.throwIllegalArgument("");
 }
 invoke(((Number) objArr2[0]).intValue(), ((Number) objArr2[1]).intValue(), ((Number) objArr2[2]).intValue(), ((Number) objArr2[3]).intValue(), ((Number) objArr2[4]).intValue(), ((Number) objArr2[5]).intValue(), ((Number) objArr2[6]).intValue(), ((Number) objArr2[7]).intValue(), ((Number) objArr2[8]).intValue(), ((Number) objArr2[9]).intValue(), ((Number) objArr2[10]).intValue(), ((Number) objArr2[11]).intValue(), ((Number) objArr2[12]).intValue(), ((Number) objArr2[13]).intValue(), ((Number) objArr2[14]).intValue(), ((Number) objArr2[15]).intValue(), ((Number) objArr2[16]).intValue(), ((Number) objArr2[17]).intValue(), ((Number) objArr2[18]).intValue(), ((Number) objArr2[19]).intValue(), ((Number) objArr2[20]).intValue(), ((Number) objArr2[21]).intValue(), ((Number) objArr2[22]).intValue());
 return Unit.INSTANCE;
 }
 public final void invoke(int va1, int va2, int va3, int va4, int va5, int va6, int va7, int va8, int va9, int va10, int va11, int va12, int va13, int va14, int va15, int va16, int va17, int va18, int va19, int va20, int va21, int va22, int va23) {
 }
}

其实也能想到， FunctionN 的 invoke 方法参数是一个可变参数就行了。


   
   interface FunctionN<out R> : Function<R>, FunctionBase<R> {
 operator fun invoke(vararg args: Any?): R
 override val arity: Int
}

到现在我们就剩下一个问题了，前面写的 (String)->Unit 是啥意思？其实大家猜也应该能猜到，这种写法只是定义 FunctionX（X代表数字）的另外一种写法， Kotlin 的设计师们认为 FunctionX 的方式不直观，便有了这种比较直观的写法，编译器最终还是会编译成 FunctionX。

表达式	FunctionX
(String) -> Unit	Function1<String,Unit>
(String,Int) -> Double	Function2<String,Int,Double>
。。。。后面的自行推导	。。。。后面的自行推导

Lambda的特殊情况

若函数最后一个参数是一个 Lambda 表达式，可以将 Lambda 写在括号外面。若函数的参数只有一个 Lambda 表达式，括号都不用写了。


   
   /**
 * 定义最后一个参数是 `Lambda` 类型
 */
fun call(name: String, block: (String) -> Unit) {
}
/**
 * 定义只有一个参数并且是 `Lambda` 类型
 */
fun call2(block: (String) -> Unit) {
}
fun main() {
 // 可以将 `Lambda` 写在括号外面
 call("阿文"){
 }
 // 只有一个参数的,并且是 `Lambda` 类型,括号都可以不写了
 call2{
 println(it)
 }
}

在 Kotlin 中，如果一个函数的行参是一个接口类型且接口只有一个方法（注意是接口且一个方法哦），可以直接传递一个 lambda 表达式。在 Andorid 中最常见的 View 点击事件注册。


   
   /**
 * 例如这样，直接就可以写
 */
 myView.setOnClickListener {
 }
 /**
 * 如需使用对应接口定义的参数，只需要定义的 lambda 定义参数即可。
 */
 myView.setOnClickListener { view ->
 }

细心的同学读源码的时候可能看到，定义 Lambda 的时候，参数通过 _ 来命名。
例如：


   
   /**
 * 定义最后一个参数是 `Lambda` 类型
 */
fun call(block: (String, Int) -> Unit) {
 block("阿文",18)
}
fun main() {
 call { _, _ ->
 }
}

其实这只是一个方便的操作，当一个 Lambda 有很多参数且我们都用不到这些参数，无需给其定义名字，用 _ 代替即可。

总结

我们来总结下 `Lambda` 的几个特点吧！

Lambda 表达式的最后一句代码的返回值是表达式的返回值
若 Lambda 的参数只有一个，可以不用定义，使用 it 代替。
可以通过 (类型1,类型2)->返回值 直观快速的定义 FunctionX 的类型。
Lambda 的最终会编译成一个实现 FunctionX 的接口类，并存在一个静态对象。
若函数最后一个参数是一个 Lambda 表达式，可以将 Lambda 定义写在括号外面。若函数的参数只有一个 Lambda 表达式，括号都不用写了。
一个函数行参是一个接口且接口只有一个方法，可以直接传递一个 lambda 表达式
当一个 Lambda 有很多参数，若我们都用不到这些参数，无需给其定义名字，用 _ 代替即可。

推荐阅读

-END--

识别二维码，关注我们

奇舞移动

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Kotlin第八讲---Lambda表达式

内容简介上一篇我们讲解了函数定义丶特点丶实现原理。这一篇我们主讲一下 Kotlin 中的 Lambda 表达式和它的本质。Lambda 早在 Java 中就存在了，但是我们一般都视而不见。Kotlin 中 Lambda 表达式扮演着很重要的角色，所以必须搞明白哦！定义Lambda表达定义一个Lambda表达式，主要使用{}来定义，下方的代码是定义一个再简单不过...
复制链接

扫一扫