在 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<String>) {
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<String>) {
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<String>) {
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<String>) {
calculate(1, 1) { a, b -> a + b }
}
- 如果 Lambda 表达式只有一个参数，并且编译器自己可以识别出签名，也可以不用声明唯一的参数并忽略
->， 该参数会隐式声明为it：
fun calculate(a: Int, cal: (Int) -> Int) {
print(cal(a))
}
fun main(args: Array<String>) {
calculate(2) { it * it }
}
// 输入
4
如果 Lambda 表达式没有参数，也可以忽略
->， 并且不会隐式声明参数it，可参考下一点的例子。如果 Lambda 表达式是调用时唯一的参数，那么圆括号也可以省略：
fun myPrint(p: () -> Unit) {
p()
}
fun main(args: Array<String>) {
myPrint {
print("timestamp is ${System.currentTimeMillis()}")
}
}
- Lambda 表达式将隐式返回最后一个表达式的值，但可以使用限定的返回语法，即通过标签显式返回一个值：
fun calculate(a: Int, cal: (Int) -> Int) {
print(cal(a))
}
fun main(args: Array<String>) {
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<String>) {
calculate(1, 2) { _, b ->
println("a 参数未使用")
b * b
}
}
- 从 Kotlin1.1 起，Lambda 表达式参数支持解构声明语法，我们通过 Kotlin 内置的
forEach()方法遍历map来测试：
fun main(args: Array<String>) {
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<Int, Int> ->
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<String>) {
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<String>) {
var str: String
calculate(1, 1) { a, b ->
str = "a + b = "
"$str${a + b}"
}
}
// 输出
a + b = 2
