Kotlin 高阶函数与 Lambda 表达式

在 Kotlin 中函数也是一等公民，这意味着我们定义的变量、函数参数、返回值都可以是函数类型的，可以像操作其它非函数值一样操作函数，确实也方便了不少。对 Android 开发者而言这无疑是一个较大的变化（虽然从 Java8 开始也有了类似的操作），同时也是 Kotlin 中相对重要的知识点，值得我们深入学习。

一、高阶函数

高阶函数是将函数作为参数或返回值的函数。这里有三个问题需要我们先思考：

如何定义一个函数的参数为函数类型？
如何使用这个函数类型的参数？
函数作为参数如何传递？

先看一个高阶函数实现的例子：

class Calculator {
    fun sum(a: Int, b: Int): Int = a + b

    fun calculate(a: Int, b: Int, cal: (Int, Int) -> Int) {
        print("a + b = ${cal(a, b)}")
    }
}

fun main(args: Array) {
    val calculator = Calculator()
    calculator.calculate(1, 1, calculator::sum)
}
// 输出
a + b = 2

现在回答上边的三个问题

cal: (Int, Int) -> Int就定义了calculate()函数的第三个参数为函数类型，同时该类型的函数有两个Int类型参数，返回值为Int类型。所以->左边括号部分为函数参数类型声明，右边为函数的返回值。注意，如果是无参函数括号()不能省略。
cal(a, b)就是使用这个函数类型的参数，和普通函数的调用没啥区别。
注意main()方法的最后一行，我们使用了calculator::sum这种写法，注意sum()方法的声明和cal参数的类型是一致的。

同样的原理，函数也可以作为返回值，简单修改上边的代码：

class Calculator {
    fun sum(a: Int, b: Int): Int = a + b
    fun getSum(): (Int, Int) -> Int = this::sum
}

fun main(args: Array) {
    val f = Calculator().getSum()
    print(f(1, 1))
}
// 输出
2

二、Lambda 表达式

1、初识 Lambda 表达式

Lambda 表达式本质上是可以传递给其它函数来作为参数的代码块。咦？这样说 Lambda 表达式也可作为高阶函数的函数类型参数的值？当然，Lambda 表达式为函数式编程提供了更好的实现。先修改上边的代码：

class Calculator {
    fun calculate(a: Int, b: Int, cal: (Int, Int) -> Int) {
        print("a + b = ${cal(a, b)}")
    }
}

fun main(args: Array) {
    val calculator = Calculator()
    calculator.calculate(1, 1, { a, b -> a + b })
}
// 输出
a + b = 2

和第一部分中主要的不同之处是，调用calculate()方法时使用了{ a, b -> a + b }作为第三个参数的值，其实{ a, b -> a + b }就是一个 Lambda 表达式，这里省略了它的参数类型，完整的如下：

{ a: Int, b: Int -> a + b }

通过例子我们可以看出 Lambda 表达式的书写规则如下：

Lambda 表达式总是被花括号{}包裹着
->左边为参数定义部分，多个参数用逗号,间隔，类似函数的参数声明，但 Lambda 表达式的参数类型可以省略（编译器可以推断类型）。
->右边为 Lambda 表达式要执行的业务逻辑，类似于函数体

2、Lambda 表达式的一些特性

如果函数的最后一个参数接受函数，那么传入的 Lambda 表达式可以放在圆括号之外：

fun calculate(a: Int, b: Int, cal: (Int, Int) -> Int) {
    print("a + b = ${cal(a, b)}")
}

fun main(args: Array) {
    calculate(1, 1) { a, b -> a + b }
}

如果 Lambda 表达式只有一个参数，并且编译器自己可以识别出签名，也可以不用声明唯一的参数并忽略->，该参数会隐式声明为it：

fun calculate(a: Int, cal: (Int) -> Int) {
    print(cal(a))
}

fun main(args: Array) {
    calculate(2) { it * it }
}
// 输入
4

如果 Lambda 表达式没有参数，也可以忽略->，并且不会隐式声明参数it，可参考下一点的例子。
如果 Lambda 表达式是调用时唯一的参数，那么圆括号也可以省略：

fun myPrint(p: () -> Unit) {
    p()
}

fun main(args: Array) {
    myPrint {
        print("timestamp is ${System.currentTimeMillis()}")
    }
}

Lambda 表达式将隐式返回最后一个表达式的值，但可以使用限定的返回语法，即通过标签显式返回一个值：

fun calculate(a: Int, cal: (Int) -> Int) {
    print(cal(a))
}

fun main(args: Array) {
    calculate(2) {
        it * it
    }

    calculate(2) {
        return@calculate it * it
    }
}

从 Kotlin1.1 起，如果 Lambda 表达式的参数未使用，则可以用下划线代替其名称：

fun calculate(a: Int, b: Int, cal: (Int, Int) -> Int) {
    print(cal(a, b))
}

fun main(args: Array) {
    calculate(1, 2) { _, b ->
        println("a 参数未使用")
        b * b
    }
}

从 Kotlin1.1 起，Lambda 表达式参数支持解构声明语法，我们通过 Kotlin 内置的forEach()方法遍历map来测试：

fun main(args: Array) {
    val map = mapOf(1 to 1, 2 to 2, 3 to 3)

    map.forEach {
        println("${it.key} to ${it.value}")
    }

    // 显示声明it参数的类型
    map.forEach { entry: Map.Entry ->
        println("${entry.key} to ${entry.value}")
    }
    // 将Map.Entry类型的it参数解构
    map.forEach { (k, v) ->
        println("$k to $v")
    }
}

三、匿名函数

其实 Lambda 表达式有一个问题，就是无法显示的指定其返回值的类型，虽然可以自动推断出返回值类型，如果确实需要显式指定返回值类型，可以匿名函数，和普通的函数类似，只是省略了函数名：

fun(a: Int, b: Int): Int {
    return a + b
}
// 或者
fun(a: Int, b: Int): Int = a + b

用法和 Lambda 表达式也有差别的：

fun calculate(a: Int, b: Int, cal: (Int, Int) -> Int) {
    println("a + b = ${cal(a, b)}")
}

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

fun main(args: Array) {
    calculate(1, 1, sum)
    calculate(2, 2, fun(a: Int, b: Int): Int = a + b)
}

四、访问闭包

Lambda 表达式或者匿名函数（以及局部函数和对象表达式）可以访问其闭包，即在外部作用域中声明的变量。与 Java 不同的是可以修改闭包中捕获的变量：

fun calculate(a: Int, b: Int, cal: (Int, Int) -> String) {
    print(cal(a, b))
}

fun main(args: Array) {
    var str: String
    calculate(1, 1) { a, b ->
        str = "a + b = "
        "$str${a + b}"
    }
}
// 输出
a + b = 2