一.lambda 表达式

lambda 在 Java 里面也有，不过 Kotlin 中的 lambda 使用起来更方便、更灵活。
lambda 其实就是匿名函数，能使代码变得更加灵活简洁，其表达式为: {变量定义 -> 代码块} ， 如：{ a, b -> a + b }

lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数

1、lambda 函数比较轻便，即用即仍，很适合需要完成一项功能，但是此功能只在此一处使用，连名字都很随意的情况下；
2、匿名函数，一般用来给 filter， map 这样的函数式编程服务;
3、作为回调函数，传递给某些应用，比如消息处理

  • 完整的 lambda 表达式
1
2
3
val method: (num1: Int, num2: Int) -> Boolean = { a: Int,b: Int ->
        a < b
    }

完整语法形式的参数声明放在圆括号内，其中 num1 和 num2只是变量的声明，可以不写，但是后面的函数体必须定义相应的变量（a，b），并有可选的类型标注， 函数体跟在一个 -> 符号之后。如果推断出的该 lambda 的返回类型不是 Unit，那么该 lambda 主体中的最后一个（或可能是单个） 表达式会视为返回值。

关于 ->:
a.其参数（如果有的话）在 -> 之前声明
b.函数体（如果存在的话）在 -> 后面

  • 因此 lambda 表达式可以简化成下面这种
1
2
3
val method: (Int, Int) -> Boolean = { a, b ->
        a < b //函数体中最后一行表达式即为 lambda 的返回值
    }
  • 还能省略函数的声明，只留下函数体
1
val method= { a: Int, b: Int -> a < b }//Kotlin可以自动推断返回类型，也可省略返回值类型的声明
  • 当 lambda 中有未用到的参数时可以用 _ 表示
1
2
3
val method: (num1: Int, num2: Int) -> Boolean = { _, _ ->
        true
    }

二.高阶函数

高阶函数就是以函数为参数的一种特殊的函数，通常与 lambda 配合起来一起使用，即 lambda 作为参数。

  • 高阶函数的声明实现与调用
1
2
3
4
5
6
7
val sum = { x: Int -> x}

fun method(age: Int, lambda: (a: Int) -> Int): Int {
        return lambda(10 * age)
    }

method(10, sum)
  • 当然高阶函数调用参数也可以直接放 lambda
1
2
3
4
5
fun method(age: Int, lambda: (a: Int) -> Int): Int {
        return lambda(10 * age)
    }

method(10, lambda = { a -> a.and(20) })
  • it 隐式参数
    当 lambda 中只有一个参数时，你不必再去单独定义一个变量来接收它，Kotlin 提供了 it 参数，代表的是你声明 lambda 时定义的那个唯一参数。
1
2
3
4
5
6
fun method(age: Int, lambda: (a: Int) -> Int): Int {
        return lambda(10 * age)
    }


method(10, lambda = {it.and(20)})//这里的 it 就是前面声明中的 a
  • 当高阶函数中的最后一个参数是 lambda 表达式时，lambda可以放在圆括号外面
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fun method(age: Int, lambda: (a: Int) -> Int): Int {
        return lambda(10 * age)
    }


method(10){
        it.and(20)
    }

//当高阶函数只有 lambda 作为参数时，圆括号也能省略
fun myMethod(lambda: (a: Int) -> Int): Int {
        return lambda(10 * age)
    }

myMethod {
        it.and(20)
    }

三.拓展函数与高阶函数

扩展函数是指在一个类上增加一种新的函数（方法），通常在某个类后面加 . 和 方法名，我们先来看看普通的扩展函数：

1
2
3
fun String.myPrint(){
    println(this)
}

在熟悉普通的扩展函数之后，我们往里面加一个 泛型 和 lambda 进去：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//Standard.kt是Kotlin库的一部分，它定义了一些基本inline函数。
//在c/c++中，为了解决一些频繁调用的小函数大量消耗栈空间的问题
//特别的引入了inline修饰符，表示为内联函数
inline fun <T> T.myAlso(block: (T) -> Unit): Unit {
    //泛型表示任何类型，只有在调用的时候才会判断你写的属于哪个类型
    block(this)
}

//Person是个类，里面有个属性 age
val p = Person(10)//age = 10

p.myAlso {
        it.age = 30//将 p 的 age 修改为30
    }
  • 当 lambda 也是一个扩展函数时
1
2
3
4
5
6
7
8
9
10
inline fun <T> T.myApply(block: T.() -> T): T {
    return this.block()
}

//Person是个类，里面有个属性 age
val p = Person(10)
    p.myApply {
        this.age = 20//将 p 的 age 修改为20
        this//lambda 返回值
    }