《Kotin 极简教程》第8章 函数式编程（FP）(2)
《Kotlin极简教程》正式上架：
点击这里 > 去京东商城购买阅读
点击这里 > 去天猫商城购买阅读
非常感谢您亲爱的读者，大家请多支持！！！有任何问题，欢迎随时与我交流~
8.2 在Kotlin中使用函数式编程
好了亲，前文中我们在函数式编程的世界里遨游了一番，现在我们把思绪收回来，放到在Kotlin中的函数式编程中来。
严格的面向对象的观点，使得很多问题的解决方案变得较为笨拙。为了将一行有用的代码包装到Runnable或者Callable 这两个Java中最流行的函数式示例中，我们不得不去写五六行模板范例代码。为了让事情简单化（在Java 8中，增加Lambda表达式的支持），我们在Kotlin中使用普通的函数来替代函数式接口。事实上，函数式编程中的函数，比C语言中的函数或者Java中的方法都要强大的多。
在Kotlin中，支持函数作为一等公民。它支持高阶函数、Lambda表达式等。我们不仅可以把函数当做普通变量一样传递、返回，还可以把它分配给变量、放进数据结构或者进行一般性的操作。它们可以是未经命名的，也就是匿名函数。我们也可以直接把一段代码丢到 {}中，这就是闭包。
在前面的章节中，其实我们已经涉及到一些关于函数的地方，我们将在这里系统地学习一下Kotlin的函数式编程。
8.2.1 Kotlin中的函数
首先，我们来看下Kotlin中函数的概念。
函数声明
Kotlin 中的函数使用 fun 关键字声明
fun double(x: Int): Int {
return 2*x
}
函数用法
调用函数使用传统的方法
fun test() {
val doubleTwo = double(2)
println("double(2) = $doubleTwo")
}
输出：double(2) = 4
调用成员函数使用点表示法
object FPBasics {
fun double(x: Int): Int {
return 2 * x
}
fun test() {
val doubleTwo = double(2)
println("double(2) = $doubleTwo")
}
}
fun main(args: Array<String>) {
FPBasics.test()
}
我们这里直接用object对象FPBasics来演示。
8.2.2 扩展函数
通过 扩展 声明完成一个类的新功能 扩展 ，而无需继承该类或使用设计模式(例如，装饰者模式)。
一个扩展String类的swap函数的例子：
fun String.swap(index1: Int, index2: Int): String {
val charArray = this.toCharArray()
val tmp = charArray[index1]
charArray[index1] = charArray[index2]
charArray[index2] = tmp
return charArrayToString(charArray)
}
fun charArrayToString(charArray: CharArray): String {
var result = ""
charArray.forEach { it -> result = result + it }
return result
}
这个 this 关键字在扩展函数内部对应到接收者对象（传过来的在点符号前的对象）。 现在，我们对任意 String 调用该函数了：
val str = "abcd"
val swapStr = str.swap(0, str.lastIndex)
println("str.swap(0, str.lastIndex) = $swapStr")
输出： str.swap(0, str.lastIndex) = dbca
8.2.3 中缀函数
在以下场景中，函数还可以用中缀表示法调用：
- 成员函数或扩展函数
- 只有一个参数
- 用
infix关键字标注
例如，给 Int 定义扩展
infix fun Int.shl(x: Int): Int {
...
}
用中缀表示法调用扩展函数：
1 shl 2
等同于这样
1.shl(2)
8.2.4 函数参数
函数参数使用 Pascal 表示法定义，即 name: type。参数用逗号隔开。每个参数必须显式指定其类型。
fun powerOf(number: Int, exponent: Int): Int {
return Math.pow(number.toDouble(), exponent.toDouble()).toInt()
}
测试代码：
val eight = powerOf(2, 3)
println("powerOf(2,3) = $eight")
输出：powerOf(2,3) = 8
默认参数
函数参数可以有默认值，当省略相应的参数时使用默认值。这可以减少重载数量。
fun add(x: Int = 0, y: Int = 0): Int {
return x + y
}
默认值通过类型后面的 = 及给出的值来定义。
测试代码：
val zero = add()
val one = add(1)
val two = add(1, 1)
println("add() = $zero")
println("add(1) = $one")
println("add(1, 1) = $two")
输出：
add() = 0
add(1) = 1
add(1, 1) = 2
另外，覆盖带默认参数的函数时，总是使用与基类型方法相同的默认参数值。
当覆盖一个带有默认参数值的方法时，签名中不带默认参数值：
open class DefaultParamBase {
open fun add(x: Int = 0, y: Int = 0): Int {
return x + y
}
}
class DefaultParam : DefaultParamBase() {
override fun add(x: Int, y: Int): Int { // 不能有默认值
return super.add(x, y)
}
}
命名参数
可以在调用函数时使用命名的函数参数。当一个函数有大量的参数或默认参数时这会非常方便。
给定以下函数
fun reformat(str: String,
normalizeCase: Boolean = true,
upperCaseFirstLetter: Boolean = true,
divideByCamelHumps: Boolean = false,
wordSeparator: Char = ' ') {
}
我们可以使用默认参数来调用它
reformat(str)
然而，当使用非默认参数调用它时，该调用看起来就像
reformat(str, true, true, false, '_')
使用命名参数我们可以使代码更具有可读性
reformat(str,
normalizeCase = true,
upperCaseFirstLetter = true,
divideByCamelHumps = false,
wordSeparator = '_'
)
并且如果我们不需要所有的参数
reformat(str, wordSeparator = '_')
可变数量的参数（Varargs）
函数的参数（通常是最后一个）可以用 vararg 修饰符标记：
fun <T> asList(vararg ts: T): List<T> {
val result = ArrayList<T>()
for (t in ts) // ts is an Array
result.add(t)
return result
}
允许将可变数量的参数传递给函数：
val list = asList(1, 2, 3)
8.2.5 函数返回类型
函数返回类型需要显式声明
具有块代码体的函数必须始终显式指定返回类型，除非他们旨在返回 Unit。
Kotlin 不推断具有块代码体的函数的返回类型，因为这样的函数在代码体中可能有复杂的控制流，并且返回类型对于读者（有时对于编译器）也是不明显的。
返回 Unit 的函数
如果一个函数不返回任何有用的值，它的返回类型是 Unit。Unit 是一种只有一个Unit 值的类型。这个值不需要显式返回:
fun printHello(name: String?): Unit {
if (name != null)
println("Hello ${name}")
else
println("Hi there!")
// `return Unit` 或者 `return` 是可选的
}
Unit 返回类型声明也是可选的。上面的代码等同于
fun printHello(name: String?) {
.....
}
8.2.6 单表达式函数
当函数返回单个表达式时，可以省略花括号并且在 = 符号之后指定代码体即可
fun double(x: Int): Int = x * 2
当返回值类型可由编译器推断时，显式声明返回类型是可选的:
fun double(x: Int) = x * 2
8.2.7 函数作用域
在 Kotlin 中函数可以在文件顶层声明，这意味着你不需要像一些语言如 Java、C# 或 Scala 那样创建一个类来保存一个函数。此外除了顶层函数，Kotlin 中函数也可以声明在局部作用域、作为成员函数以及扩展函数。
局部函数（嵌套函数）
Kotlin 支持局部函数，即一个函数在另一个函数内部
fun sum(x: Int, y: Int, z: Int): Int {
val delta = 0;
fun add(a: Int, b: Int): Int {
return a + b + delta
}
return add(x + add(y, z))
}
局部函数可以访问外部函数（即闭包）中的局部变量delta。
println("sum(1,2,3) = ${sum(0, 1, 2, 3)}")
输出：
sum(1,2,3) = 6
成员函数
成员函数是在类或对象内部定义的函数
class Sample() {
fun foo() { print("Foo") }
}
成员函数以点表示法调用
Sample().foo() // 创建类 Sample 实例并调用 foo
8.2.8 泛型函数
函数可以有泛型参数，通过在函数名前使用尖括号指定。
例如Iterable的map函数：
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}
8.2.9 高阶函数
高阶函数是将函数用作参数或返回值的函数。例如，Iterable的filter函数：
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
return filterTo(ArrayList<T>(), predicate)
}
它的输入参数predicate: (T) -> Boolean就是一个函数。其中，函数类型声明的语法是：
(X)->Y
表示这个函数是从类型X到类型Y的映射。即这个函数输入X类型，输出Y类型。
这个函数我们这样调用：
fun isOdd(x: Int): Boolean {
return x % 2 == 1
}
val list = listOf(1, 2, 3, 4, 5)
list.filter(::isOdd)
其中，::用来引用一个函数。
8.2.10 匿名函数
我们也可以使用匿名函数来实现这个predicate函数：
list.filter((fun(x: Int): Boolean {
return x % 2 == 1
}))
8.2.11 Lambda 表达式
我们也可以直接使用更简单的Lambda表达式来实现一个predicate函数：
list.filter {
it % 2 == 1
}
- lambda 表达式总是被大括号
{}括着 - 其参数（如果有的话）在
->之前声明（参数类型可以省略） - 函数体（如果存在的话）在
->后面
上面的写法跟：
list.filter({
it % 2 == 1
})
等价，如果 lambda 是该调用的唯一参数，则调用中的圆括号可以省略。
使用Lambda表达式定义一个函数字面值：
>>> val sum = { x: Int, y: Int -> x + y }
>>> sum(1,1)
2
我们在使用嵌套的Lambda表达式来定义一个柯里化的sum函数：
>>> val sum = {x:Int -> {y:Int -> x+y }}
>>> sum
(kotlin.Int) -> (kotlin.Int) -> kotlin.Int
>>> sum(1)(1)
2
8.2.11 it：单个参数的隐式名称
Kotlin中另一个有用的约定是，如果函数字面值只有一个参数，
那么它的声明可以省略（连同 ->），其名称是 it。
代码示例：
>>> val list = listOf(1,2,3,4,5)
>>> list.map { it * 2 }
[2, 4, 6, 8, 10]
8.2.12 闭包（Closure）
Lambda 表达式或者匿名函数，以及局部函数和对象表达式（object declarations）可以访问其 闭包 ，即在外部作用域中声明的变量。 与 Java 不同的是可以修改闭包中捕获的变量：
fun sumGTZero(c: Iterable<Int>): Int {
var sum = 0
c.filter { it > 0 }.forEach {
sum += it
}
return sum
}
val list = listOf(1, 2, 3, 4, 5)
sumGTZero(list) // 输出 15
我们再使用闭包来写一个使用Java中的Thread接口的例子：
fun closureDemo() {
Thread({
for (i in 1..10) {
println("I = $i")
Thread.sleep(1000)
}
}).start()
Thread({
for (j in 10..20) {
println("J = $j")
Thread.sleep(2000)
}
Thread.sleep(1000)
}).start()
}
一个输出：
I = 1
J = 10
I = 2
I = 3
...
J = 20
8.2.13 带接收者的函数字面值
Kotlin 提供了使用指定的 接收者对象 调用函数字面值的功能。
使用匿名函数的语法，我们可以直接指定函数字面值的接收者类型。
下面我们使用带接收者的函数类型声明一个变量，并在之后使用它。代码示例：
>>> val sum = fun Int.(other: Int): Int = this + other
>>> 1.sum(1)
2
当接收者类型可以从上下文推断时，lambda 表达式可以用作带接收者的函数字面值。
class HTML {
fun body() {
println("HTML BODY")
}
}
fun html(init: HTML.() -> Unit): HTML { // HTML.()中的HTML是接受者类型
val html = HTML() // 创建接收者对象
html.init() // 将该接收者对象传给该 lambda
return html
}
测试代码：
html {
body()
}
输出：HTML BODY
使用这个特性，我们可以构建一个HTML的DSL语言。
8.2.14 具体化的类型参数
有时候我们需要访问一个参数类型：
fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
var p = parent
while (p != null && !clazz.isInstance(p)) {
p = p.parent
}
@Suppress("UNCHECKED_CAST")
return p as T?
}
在这里我们向上遍历一棵树并且检查每个节点是不是特定的类型。
这都没有问题，但是调用处不是很优雅：
treeNode.findParentOfType(MyTreeNode::class.java)
我们真正想要的只是传一个类型给该函数，即像这样调用它：
treeNode.findParentOfType<MyTreeNode>()
为能够这么做，内联函数支持具体化的类型参数，于是我们可以这样写：
inline fun <reified T> TreeNode.findParentOfType(): T? {
var p = parent
while (p != null && p !is T) {
p = p.parent
}
return p as T?
}
我们使用 reified 修饰符来限定类型参数，现在可以在函数内部访问它了，
几乎就像是一个普通的类一样。由于函数是内联的，不需要反射，正常的操作符如 !is 和 as 现在都能用了。
虽然在许多情况下可能不需要反射，但我们仍然可以对一个具体化的类型参数使用它：
inline fun <reified T> membersOf() = T::class.members
fun main(s: Array<String>) {
println(membersOf<StringBuilder>().joinToString("\n"))
}
普通的函数（未标记为内联函数的）没有具体化参数。
8.2.10 尾递归tailrec
Kotlin 支持一种称为尾递归的函数式编程风格。 这允许一些通常用循环写的算法改用递归函数来写，而无堆栈溢出的风险。 当一个函数用 tailrec 修饰符标记并满足所需的形式时，编译器会优化该递归，生成一个快速而高效的基于循环的版本。
tailrec fun findFixPoint(x: Double = 1.0): Double
= if (x == Math.cos(x)) x else findFixPoint(Math.cos(x)) // 函数必须将其自身调用作为它执行的最后一个操作
这段代码计算余弦的不动点（fixpoint of cosine），这是一个数学常数。 它只是重复地从 1.0 开始调用 Math.cos，直到结果不再改变，产生0.7390851332151607的结果。最终代码相当于这种更传统风格的代码：
private fun findFixPoint(): Double {
var x = 1.0
while (true) {
val y = Math.cos(x)
if (x == y) return y
x = y
}
}
要符合 tailrec 修饰符的条件的话，函数必须将其自身调用作为它执行的最后一个操作。在递归调用后有更多代码时，不能使用尾递归，并且不能用在 try/catch/finally 块中。尾部递归在 JVM 后端中支持。
Kotlin 还为集合类引入了许多扩展函数。例如，使用 map() 和 filter() 函数可以流畅地操纵数据，具体的函数的使用以及示例我们已经在 集合类 章节中介绍。
本章小结
本章我们一起学习了函数式编程的简史、Lambda演算、Y组合子与递归等核心函数式的编程思想等相关内容。然后重点介绍了在Kotlin中如何使用函数式风格编程，其中重点介绍了Kotlin中函数的相关知识，以及高阶函数、Lambda表达式、闭包等核心语法，并给出相应的实例说明。
我们将在下一章 中介绍Kotlin的 轻量级线程：协程（Coroutines）的相关知识，我们将看到在Kotlin中，程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。
