Lambda 是一种法语即表达式，也可以称为闭包，早在Java8发布中成为最重要的新特性
是允许将函数作为一个方法的参数，即函数作为参数传递进方法中
使用Lambda表达式可以使用代码变得更加简洁明了
定义Lambda表达式
主要是使用{}来定义，例如
val lambda = {}
@Test
fun main() {
//方式一
lambda()
//方式二
lambda.invoke()
}
带参数Lambda表达式
定义有参数的Lambda通过{参数A:类型,参数B:类型 ->} 完成，注意->
val lambda = { name: String, age: Int ->
println("this name:$name age:$age")
}
@Test
fun main() {
//调用
lambda("张三", 10)
//调用
lambda.invoke("李四", 12)
}
//LogCat
this name:张三 age:10
this name:李四 age:12
带返回值的Lambda表达式
一般函数如果需要返回值通过return来确定，而Lambda表达式是最后一句代码的返回值确定，也就是Lambda可以省略
class ExampleUnitTest {
val lambda = { name: String, age: Int ->
println("this name:$name age:$age")
//表示没有返回值，省略默认为Unit
Unit
}
@Test
fun main() {
//调用
lambda("张三", 10)
//调用
lambda.invoke("李四", 12)
println(lambda)
}
}
通过编译JAVA文件看看，发现了有什么不一样
@NotNull
private final Function2 lambda;
@NotNull
public final Function2 getLambda() {
return this.lambda;
}
@Test
public final void main() {
this.lambda.invoke("张三", 10);
this.lambda.invoke("李四", 12);
Function2 var1 = this.lambda;
boolean var2 = false;
System.out.println(var1);
}
public ExampleUnitTest() {
this.lambda = (Function2)null.INSTANCE;
}
-
Lambda表达式就一个接口FunctionN - 携带的参数个数与N 等同
- 默认返回的是自己
- 通过
INSTANCE实例化
Lambda使用
在Kotlin中可以将函数以参数的形式传递，想一下为什么可以传递？
小笔记：
其本质是传递了一个FunctionN的接口对象，定义的Lambda表达式都存放到了一个变量中，吉然能存在变量中，那么Lambda表达式肯定也可以来回传递
//成功
val success = { success: String ->
println(success)
}
//错误
val error = { error: String ->
println(error)
}
//返回Call
fun call(success: (String) -> Unit, error: (String) -> Unit) {
//通过随机数来判断
if ((0..400).random() >= 200) {
success("成功")
} else {
error("错误")
}
}
@Test
fun main() {
call(success, error)
}
这样写不是不可以，因为在Kotlin的函数是支持函数嵌套，想一下
@Test
fun main() {
fun content(){
}
}
那么改进一下：
//返回Call
fun call(success: (String) -> Unit, error: (String) -> Unit) {
if ((0..400).random() >= 200) {
success("成功")
} else {
error("错误")
}
}
@Test
fun main() {
call({
println("main $it")
},{ error ->
println("main $error")
})
}
观察得到几个意味如下：
- 调用的时候
call方法的时候，嵌套定义Lambda表达式，怎么没用定义变量，it又是什么东西？ -
call方法定义的行参中的类型(String) -> Unit是什么鬼？
疑问一：
在Lambda 表达式函数只需要一个参数，是可以不用写，系统会默认使用it来代替，当然也可以自定义如error -> 切记别忘记了箭头
疑问二：
先看看转变的JAVA代码：
public final void call(@NotNull Function1 success, @NotNull Function1 error) {
Intrinsics.checkNotNullParameter(success, "success");
Intrinsics.checkNotNullParameter(error, "error");
byte var3 = 0;
IntRange var5 = new IntRange(var3, 400);
boolean var4 = false;
if (RangesKt.random(var5, (Random)Random.Default) >= 200) {
success.invoke("成功");
} else {
error.invoke("错误");
}
}
@Test
public final void main() {
this.call((Function1)null.INSTANCE, (Function1)null.INSTANCE);
}
可以看出(String) -> Unit 其实就是一个 Function1 接口
public interface Function1<in P1, out R> : Function<R> {
/** Invokes the function with the specified argument. */
public operator fun invoke(p1: P1): R
}
也就是几个参数，对应具体FunctionN 接口 (最多22个参数)
| 表达式 | FunctionN 最大值【Function22】 |
|---|---|
| (String) -> Unit | Function1<String,Unit> |
| (String,Int) -> Double | Function2<String,Int,Double> |
| .... | ... |
更多可以回看 Kotlin函数 / 嵌套当参数传递
总结
-
Lambda表达式最后一行代码返回值就是表达式的返回值 - 若
Lambda的参数只有一个，可以不用定义，使用默认it定义， 或者是 自定义xxx -> - 通过
(类型1，类型2) -> 返回值最直观的定义FunctionN接口类型，并且存在一个静态对象 -
Lambda的参数若是用不到，无需定义声明，_代替即可
