本质
一段代码封装成匿名函数
特点
1.lambda 表达式必须通过 {} 来包裹
2.如果 lambda 声明了参数部分的类型，且返回值支持类型推导，则 lambda 表达式变量就可以省略函数类型声明
3.如果 lambda 变量声明了函数类型，那么 lambda 表达式的参数部分的类型就可以省略
4.如果 lambda 表达式返回的不是 Unit 类型，则默认最后一行表达式的值类型就是返回值类型，Lambda 的返回值别写 return，如果你写了，它会把这个作为它外层的函数的返回值来直接结束外层函数。当然如果你就是想这么做那没问题啊，但如果你是只是想返回 Lambda，这么写就出错了。
另外因为 Lambda 是个代码块，它总能根据最后一行代码来推断出返回值类型，所以它的返回值类型确实可以不写。实际上，Kotlin 的 Lambda 也是写不了返回值类型的，语法上就不支持。
简写
1.如果一个函数的最后一个实参是lambda表达式，可以把lambda表达式提到小括号外边
2.如果lambda是函数的唯一实参，小括号可以直接省略
3.kotlin可以推导出的参数类型可以省略
4.kotlin中可以使用it默认参数名代替参数名称
语法
完整语法：val sum: (Int, Int) -> Int = {x: Int, y: Int -> x + y}
简写1：val sum: (Int, Int) -> Int = {x, y -> x + y}
简写2：val sum={x:Int, y:Int -> x+y}
完整语法说明： 函数类型 -> Lambda表达式
函数类型：(Int, Int) -> Int
lambda表达式 {x: Int, y: Int -> x + y}
完整Lambda表达式说明：{参数1：参数类型，参数2: 参数类型 -> 函数体}
- 无参数的情况
val/var 变量名 = { 操作的代码 }
val test = { println("无参数") }
- 有参数的情况
val/var 变量名 : (参数的类型，参数类型，...) -> 返回值类型
= {参数1，参数2，... -> 操作参数的代码 }
val sum: (Int, Int) -> Int = {x, y -> x + y}
val/var 变量名 = { 参数1 ： 类型，参数2 : 类型, ... ->
操作参数的代码 }
val sum={x:Int, y:Int -> x+y}
- lambda表达式作为函数中的参数的时候
fun test(a : Int, 参数名 : (参数1 ： 类型，参数2 : 类型, ... )
-> 表达式返回类型){
...
}
fun test(a : Int , b : (num1 : Int , num2 : Int) -> Int) : Int{
return a + b.invoke(3,5)
}
函数类型
- 简单的函数类型
//无参、无返回值的函数类型(Unit 返回类型不可省略)
() -> Unit
//接收T类型参数、无返回值的函数类型
(T) -> Unit
//接收T类型和A类型参数、无返回值的函数类型(多个参数同理)
(T,A) -> Unit
//接收T类型参数，并且返回R类型值的函数类型
(T) -> R
//接收T类型和A类型参数、并且返回R类型值的函数类型(多个参数同理)
(T,A) -> R
- 复杂的函数类型
(T,(A,B) -> C) -> R
fun a ( funParam : ( Int ) -> String ): String {
return funParam ( 1 )
}
函数类型不只可以作为函数的参数类型，还可以作为函数的返回值类型
fun c ( param : Int ): ( Int ) -> Unit {
...
}
函数 和 lambda表达式
- fun 在没有等号、只有花括号的情况下，就是代码块函数体，如果返回值非 Unit，必须带 return
fun foo(x: Int) {
print(x)
}
fun foo(x: Int, y: Int): Int {
return x + y
}
- fun 带有等号，没有花括号，是单表达式函数体，可以省略 return
fun foo(x: Int, y: Int) = x + y
- 不管是用 val 还是 fun 声明，如果是等号加花括号的语法，就是声明一个 lambda 表达式
val foo = { x: Int, y: Int ->
x + y
}
// 调用方式： foo.invoke(1, 2) 或者 foo(1, 2)
fun foo(x: Int) = { y: Int ->
x + y
}
// 调用方式： foo(1).invoke(2) 或者 foo(1)(2)
- lambda 表达式自调用
{x: Int, y: Int -> x + y}(1, 2)
Lambda之it
- it并不是Kotlin中的一个关键字(保留字)
- it是在当一个高阶函数中Lambda表达式的参数只有一个的时候可以使用it来使用此参数。it可表示为单个参数的隐式名称，是Kotlin语言约定的
// 这里举例一个语言自带的一个高阶函数filter,
//此函数的作用是过滤掉不满足条件的值。
val arr = arrayOf(1,3,5,7,9)
// 过滤掉数组中元素小于5的元素，取其第一个打印。
// 这里的it就表示每一个元素。
println(arr.filter { it < 5 }.component1())
//实例2
fun test(num1 : Int, bool : (Int) -> Boolean) : Int{
return if (bool(num1)){ num1 } else 0
}
println(test(10,{it > 5}))
println(test(4,{it > 5}))
Lambda之下划线（_）
Lambda表达式中，可以用下划线(_)表示未使用的参数，表示不处理这个参数
val map = mapOf("key1" to "value1","key2" to "value2","key3" to "value3")
map.forEach{
key , value -> println("$key \t $value")
}
// 不需要key的时候
map.forEach{
_ , value -> println("$value")
}
在lambda表达式，只支持单抽象方法模型，也就是说设计的接口里面只有一个抽象的方法，才符合lambda表达式的规则，多个回调方法不支持。