kotlin Lambda表达式

本质

一段代码封装成匿名函数

特点

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表达式

  1. fun 在没有等号、只有花括号的情况下,就是代码块函数体,如果返回值非 Unit,必须带 return
fun foo(x: Int) {
        print(x)
    }

fun foo(x: Int, y: Int): Int {
        return x + y
}
  1. fun 带有等号,没有花括号,是单表达式函数体,可以省略 return
fun foo(x: Int, y: Int) = x + y
  1. 不管是用 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)
  1. 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表达式的规则,多个回调方法不支持。

你可能感兴趣的:(kotlin Lambda表达式)