Kotlin lambda学习

1、lambda基本形式

• lambda表达式存在于 { }中；
• 参数及参数类型可在 -> 左边，函数体在 -> 右边；
• lambda表达式返回值总是返回函数体内部最后一行表达式的值
• 主要有一下3种：

• 1.1、无参数

  val 函数名 = { 函数体 }

  val hello = { println("hello kotlin") }
  
  // 等价于函数
  fun hello() {
      println("hello kotlin")
  }

1.2、有参数

    完整表达方式：
    val 函数名 : (参数1类型, 参数2类型, …) -> 返回值类型 = { 参数1, 参数2, … -> 函数体 }
    表达式返回值类型可自动推断形式
    val 函数名 = { 参数1:类型1, 参数2:类型2, … -> 函数体 }

val sum: (Int, Int) -> Int = { a, b -> a + b }
// 等价于
val sum = { a: Int, b: Int -> a + b }

// 等价于函数
fun sum(a: Int, b: Int): Int {
    return a + b
}

    当只有1个参数的时候,返回值中的参数形参可以省略，引用时通过it进行引用

lambda的调用有2种方式，

    一种是通过()来进行调用，
    一种是通过invoke()函数调用，可以使用下划线表示没有使用的参数

fun main(args: Array<String>) {
    val lambda = { println("test") }
    lambda()
    lambda.invoke()
}

1.3、匿名函数

匿名函数形式为：
val 函数名 = fun(参数1:类型1, 参数2:类型2, …): 返回值类型 { 函数体 }

val sum = fun(a: Int, b: Int): Int {
    return a + b
}

// 等价于函数
fun sum(a: Int, b: Int): Int {
    return a + b

基本使用

Lambda表达式的基本语法结构：
{(参数名1： 参数类型， 参数2： 参数类型 … 参数n): 参数类型 -> 函数体}

标准的Lambda表达式的样子就是大括号左侧定义参数，用 -> 分隔开，右边是具体的函数体。
在Kotlin当中的函数体最后一行便是返回值。

例如：

1 2 3 4 5 6 7 8 9 10

//无参、无返回值的函数类型(Unit 返回类型不可省略) {() -> Unit} //接收T类型参数、无返回值的函数类型 {(T) -> Unit} //接收T类型和A类型参数、无返回值的函数类型(多个参数同理) {(T,A) -> Unit} //接收T类型参数，并且返回R类型值的函数类型 {(T) -> R} //接收T类型和A类型参数、并且返回R类型值的函数类型(多个参数同理) {(T,A) -> R}

知道怎么看之后，我们就需要学习如何去简化，简化这部分就是很容易导致看不懂的情况出现。

Lambda表达式的简化

1、 可以将Lambda表达式作为参数传入方法中。

1 2 3 4 5 6

val list = listOf("Apple", "Banana", "Orange", "Pear", "Watermelon")        val lambda = { (fruit: String) -> fruit.length }    // lambda表达式做变量        //注意这里是小括号，括号中接收的Lambda参数        val maxLengthFruit = list.maxBy(lambda)            //传入        val maxLengthFruit = list.maxBy({ fruit: String -> fruit.length })    //简化1        println("单词最长的水果：" + maxLengthFruit)

2、当变量是最后一个变量，且是lambda表达式时，可以将表达式移动到括号后面：

1 2 3 4 5 6 7

val list = listOf("Apple", "Banana", "Orange", "Pear", "Watermelon")         //val lambda = { fruit: String -> fruit.length }    // lambda表达式做变量         //注意这里是小括号，括号中接收的Lambda参数         // val maxLengthFruit = list.maxBy(lambda)            //传入         // val maxLengthFruit = list.maxBy({ fruit: String -> fruit.length })    //简化1         val maxLengthFruit = list.maxBy(){ fruit: String -> fruit.length }   //简化2         println("单词最长的水果：" + maxLengthFruit)

3、当变量是唯一的一个变量时，可以省略括号：

1 2 3 4 5 6 7 8

val list = listOf("Apple", "Banana", "Orange", "Pear", "Watermelon")         //val lambda = { fruit: String -> fruit.length }    // lambda表达式做变量         //注意这里是小括号，括号中接收的Lambda参数         // val maxLengthFruit = list.maxBy(lambda)            //传入         // val maxLengthFruit = list.maxBy({ fruit: String -> fruit.length })    //简化1         // val maxLengthFruit = list.maxBy(){ fruit: String -> fruit.length }   //简化2         val maxLengthFruit = list.maxBy{ fruit: String -> fruit.length }   // 简化3         println("单词最长的水果：" + maxLengthFruit)

4、使用kotlin的类型推断，省略类型声明：

1 2 3 4 5 6 7 8 9

val list = listOf("Apple", "Banana", "Orange", "Pear", "Watermelon")         //val lambda = { fruit: String -> fruit.length }    // lambda表达式做变量         //注意这里是小括号，括号中接收的Lambda参数         // val maxLengthFruit = list.maxBy(lambda)            //传入         // val maxLengthFruit = list.maxBy({ fruit: String -> fruit.length })    //简化1         // val maxLengthFruit = list.maxBy(){ fruit: String -> fruit.length }   //简化2         // val maxLengthFruit = list.maxBy{ fruit: String -> fruit.length }   // 简化3         val maxLengthFruit = list.maxBy{ fruit -> fruit.length }  // 简化4         println("单词最长的水果：" + maxLengthFruit)

5、当变量只有一个参数时，可以使用it来进行指代：

1 2 3 4 5 6 7 8 9 10

val list = listOf("Apple", "Banana", "Orange", "Pear", "Watermelon")         //val lambda = { fruit: String -> fruit.length }    // lambda表达式做变量         //注意这里是小括号，括号中接收的Lambda参数         // val maxLengthFruit = list.maxBy(lambda)            //传入         // val maxLengthFruit = list.maxBy({ fruit: String -> fruit.length })    //简化1         // val maxLengthFruit = list.maxBy(){ fruit: String -> fruit.length }   //简化2         // val maxLengthFruit = list.maxBy{ fruit: String -> fruit.length }   // 简化3         // val maxLengthFruit = list.maxBy{ fruit -> fruit.length }  // 简化4         val maxLengthFruit = list.maxBy{ it.length }    // 简化5         println("单词最长的水果：" + maxLengthFruit)

可以看懂这些，基本上对koltin当中的Lambda表达式的基本使用和阅读就没有问题啦！