本篇文章主要介绍以下几个知识点：
- 高阶函数
- 内联函数
- noinline 与 crossinline
- 高阶函数的应用
内容参考自第一行代码第3版
1. 定义高阶函数
前面学习了如map, filter, run, apply 等函数，它们有一个共同的特点：传入一个 Lambda 表达式作为参数。
这种接收 Lambda 参数的函数可称为具有函数式编程风格的 API，若要自定义函数式 API，则需要借助高阶函数来实现。
高阶函数：接收另一个函数（函数类型）作为参数，或返回值的类型是另一个函数。
函数类型的基本规则定义如下：
// -> 左边部分是用来声明该函数接收什么参数，多个参数可用逗号隔开，若不接收参数则写空括号即可
// -> 右边部分是用来声明该函数的返回值是什么类型，若没有返回值就使用 Unit (类似Java中的void)
(String, Int) -> Unit
把上述函数类型添加到某个函数的参数声明或者返回值声明上，这个函数就是一个高阶函数了：
// example() 函数接收了一个函数类型的参数，这边 example() 函数就是一个高阶函数
fun example(func: (String, Int) -> Unit) {
func("hello", 123)
}
高阶函数允许让函数类型的参数来决定函数的执行逻辑。同一个高阶函数，传入不同的函数类型，其执行逻辑和最终返回结果就可能不同。
下面举个栗子，定义一个 num1AndNum2() 的高阶函数：
// 这边第三个参数是一个接收两个整型参数并且返回值也是整型的函数类型参数
fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
val result = operation(num1, num2)
return result
}
接着定义与上面函数类型(第三个参数)相匹配的函数如下：
// 两数相加并返回
fun plus(num1: Int, num2: Int): Int {
return num1 + num2
}
// 两数相减并返回
fun minus(num1: Int, num2: Int): Int {
return num1 - num2
}
定义好上述函数后，就可以调用 num1AndNum2() 函数了：
fun main() {
val num1 = 100
val num2 = 200
val result1 = num1AndNum2(num1, num2, ::plus)
val result2 = num1AndNum2(num1, num2, ::minus)
println("result1 is $result1")
println("result2 is $result2")
}
除了用上面的方式来调用高阶函数，Kotlin 也支持用 Lambda 表达式、匿名函数、成员引用等来调用高阶函数，如使用 Lambda 表达式来实现上述代码：
fun main() {
val num1 = 100
val num2 = 200
val result1 = num1AndNum2(num1, num2) { n1, n2 ->
n1 + n2
}
val result2 = num1AndNum2(num1, num2) { n1, n2 ->
n1 - n2
}
println("result1 is $result1")
println("result2 is $result2")
}
这样用 Lambda 表达式来调用就无需定义 plus() 和 minus() 函数了。
回顾之前的 apply() 函数的例子：
fun main() {
val list = listOf("apple", "orange", "pear")
// apply 函数返回的是 StringBuilder 对象
val applyResult = StringBuilder().apply {
append("开始吃水果：\n")
for (fruit in list) {
append(fruit).append("\n")
}
append("吃完全部水果!")
}
println(applyResult.toString())
}
若要用高阶函数实现类似的功能，可以给StringBuilder 类定义一个 build 扩展函数，这个扩展函数接收一个函数类型参数并且返回值类型也是 StringBuilder，如下：
// 在函数类型的前面加上 ClassName. 表示这个函数类型是定义在哪个类中的
// 这边在函数类型的前面加上了一个 StringBuilder.
// 这样调用 build 函数时传入的 Lambda 表达式就会自动拥有 StringBuilder 的上下文
fun StringBuilder.build(block: StringBuilder.() -> Unit): StringBuilder {
return this
}
这样就可以用定义的 build 扩展函数来实现上面 apply() 函数的例子了：
fun main() {
val list = listOf("apple", "orange", "pear")
val result = StringBuilder().build {
append("开始吃水果：\n")
for (fruit in list) {
append(fruit).append("\n")
}
append("吃完全部水果!")
}
println(result.toString())
}
2. 内联函数
首先来简单分析下高阶函数的实现原理，比如上面的 num1AndNum2() 函数：
fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
val result = operation(num1, num2)
return result
}
fun main() {
val num1 = 100
val num2 = 200
val result = num1AndNum2(num1, num2) { n1, n2 ->
n1 + n2
}
}
由于 Kotlin 的代码最终还是要编译成 Java 字节码的，但 Java 中并无高阶函数的概念，从而编译器会将这些高阶函数的语法转换成 Java 支持的语法结构，上面代码被转换成 Java 代码大致如下：
public static int num1AndNum2(int num1, int num2, Function operation) {
int result = (int) operation.invoke(num1, num2);
return result;
}
public static void main() {
int num1 = 100;
int num2 = 200;
int result = num1AndNum2(num1, num2, new Fuction() {
@Override
public Integer invoke(Integer n1, Integer n2) {
return n1 + n2;
}
});
}
原来一直使用的 Lambda 表达式在底层被转化成了匿名类的实现方式，这样每调用一次 Lambda 表达式，就会创建一个新的匿名内部类，从而造成额外的内存和性能开销。
为了解决这个问题，Kotlin 提供了内联函数的功能，它可以把使用 Lambda 表达式带来的运行时开销完全消除。
使用内联函数只需在定义高阶函数时加上 inline 关键字即可：
inline fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
val result = operation(num1, num2)
return result
}
内联函数的工作原理：Kotlin 编译器会将内联函数中的代码在编译时自动替换到调用它的地方，这样也就不存在运行时的开销了。
3. noinline 与 crossinline
当一个高阶函数中接收了两个或多个函数类型的参数，若给函数加上 inline 关键字，那么编译器会自动将所有引用的 Lambda 表达式全部进行内联。
若此时只想内联其中的一个 Lambda 表达式，就可以使用 noinline 关键字了：
// block2 参数前加了 noinline 关键字后，只会对 block1 参数所引用的 Lambda 表达式进行内联
inline fun inlineTest(block1: () -> Unit, noinline block2: () -> Unit) { }
为什么 Kotlin 还要提供一个 noinline 关键字来排除内联功能？
内联的函数类型参数在编译时会被进行替换，因此它没有真正的参数属性。
非内联的函数类型参数可自由传递给其他任何函数，它是一个真实的参数。
而内联的函数类型参数值允许传递给另外一个内联函数，这也是它的局限性。
另外，内联函数所引用的 Lambda 表达式可使用 return 关键字来进行函数返回，而非内联函数只能进行局部返回。举个栗子，如分别定义非内联和内联高阶函数如下：
fun noinlineTest(str: String, block: (String) -> Unit) {
block(str)
}
inline fun inlineTest(str: String, block: (String) -> Unit) {
block(str)
}
fun main() {
val str = ""
noinlineTest(str) {
// 非内联函数中引用的 Lambda 表达式是不允许直接使用 return 关键字的
// 这边使用 return@noinlineTest 的写法，表示进行局部返回
if (it.isEmpty()) return@noinlineTest
println(it)
}
inlineTest(str) {
// 内联函数中引用的 Lambda 表达式可以使用 return 关键字
// 这边的 return 代表的是返回外层的调用函数，即 main() 函数
if (it.isEmpty()) return
println(it)
}
}
将高阶函数声明成内联函数是一种良好的编程习惯，大部分高阶函数是可以直接声明成内联函数的，但也有特例，如下：
上面代码若没有加上 inline 关键字时是不会报错，加上后就会报上面的错误。
上面代码在 runRunnable() 函数中创建了一个 Runnable 对象，在它的 Lambda 表达式中调用了传入的函数类型参数。而 Lambda 表达式在编译时会被转换成匿名类的实现方式，也就是说上面代码实际上是在匿名类中调用了传入的参数类型参数。
内联函数的 Lambda 表达式中允许使用 return 关键字，和高阶函数的匿名类实现中不允许使用 return 关键子之间造成了冲突，从而出现上述报错。
即在高阶函数中创建了另外的 Lambda 或匿名类的实现，并且在这些实现中调用函数类型参数，此时声明成内联函数就会报错。
当然，借助 crossinline 关键字可以解决上面的问题：
inline fun runRunnable(crossinline block: () -> Unit) {
val runnable = Runnable {
block()
}
runnable.run()
}
在函数类型参数的前面加上 crossinline 声明，就可以编译通过了。
crossinline 关键字是用于保证在内联函数的 Lambda 表达式中一定不会使用 return 关键字。
声明了 crossinline 后，就无法在调用 runRunnable() 函数时的 Lambda 表达式中使用 return 进行函数返回，但仍然可用 return@runRunnable 的写法进行局部返回。
小结：除了在 return 关键字使用上有所区别，crossinline 保留了内联函数的所有其他特性。
4. 高阶函数的应用
4.1 简化 SharedPreferences 的用法
高阶函数非常适用与简化各种 API 的调用，一些简化后在易用性和可读性上都会有很大提升。
比如 SharedPreferences 原来的用法如下：
val editor = getSharedPreferences("data", Context.MODE_PRIVATE).edit()
editor.putString("name", "Wonderful")
editor.putInt("age", 18)
editor.apply()
接下来使用高阶函数简化 SharedPreferences 的用法，向 SharedPreferences 添加一个扩展函数open 如下：
fun SharedPreferences.open(block: SharedPreferences.Editor.() -> Unit) {
val editor = edit()
editor.block()
editor.apply()
}
这样再使用 SharedPreferences 存储数据是就更加方便了：
getSharedPreferences("data", Context.MODE_PRIVATE).open {
putString("name", "Wonderful")
putInt("age", 18)
}
当然，Google 提供的 KTX 扩展库中已经包含了上述的简化用法。
4.2 简化 ContentValues 的用法
ContentValues 主要用于结合 SQLiteDatabase 的 API 存储和修改数据库中的数据，用法如下：
val values = ContentValues()
values.put("name", "Wonderful")
values.put("age", 18)
values.put("height", 200.5)
db.insert("Person", null, values)
上面代码可以用 apply 简化，但这里先用 Pair 对象(键值对)来定义一个 cvOf() 方法：
// 接收一个 Pair 参数，
// vararg 关键字允许传入任意多的参数（即 Java 中的可变参数列表）
// Any 是 Kotlin 中所有类的共同基类（相当于 Java 中的 Object）
fun cvOf(vararg pairs: Pair): ContentValues {
}
继续完善方法如下：
fun cvOf(vararg pairs: Pair): ContentValues {
val cv = ContentValues()
for (pair in pairs) {
val key = pair.first
val value = pair.second
when (value) {
is Int -> cv.put(key, value)
is Long -> cv.put(key, value)
is Short -> cv.put(key, value)
is Float -> cv.put(key, value)
is Double -> cv.put(key, value)
is Boolean -> cv.put(key, value)
is String -> cv.put(key, value)
is Byte -> cv.put(key, value)
is ByteArray -> cv.put(key, value)
null -> cv.putNull(key)
}
}
return cv
}
当然可以用 apply 进一步优化：
fun cvOf(vararg pairs: Pair) = ContentValues().apply {
for (pair in pairs) {
val key = pair.first
when (val value = pair.second) {
is Int -> put(key, value)
is Long -> put(key, value)
is Short -> put(key, value)
is Float -> put(key, value)
is Double -> put(key, value)
is Boolean -> put(key, value)
is String -> put(key, value)
is Byte -> put(key, value)
is ByteArray -> put(key, value)
null -> putNull(key)
}
}
}
这样使用 ContentValues 时就更加简单了，比如开头代码可改为如下：
val values = cvOf("name" to "Wonderful", "age" to 18, "height" to 200.5)
db.insert("Person", null, values)
当然，Google 提供的 KTX 扩展库中已经包含了上述的简化用法：contentValuesOf()。
本篇文章就介绍到这。