Kotlin 函式6 - 高階函式

Kotlin 函式6 - 高階函式

---

1. 基本概念

簡單的說，高階函式就是把一個函式作為另一個函式的引數或者返回值的函式，

1. 舉個例子：

Array.forEach(action: (T) -> Unit): Unit

上面的 forEach() 函式引數是一個 接收一個任意型別引數，同時沒有返回值 的函式，所以只要符合要求的函式都可以作為其引數使用；

val array = arrayOf("a", "b", "", "c", "d", "e", "f")
array.forEach({ element -> println(element) })

根據之前使用 lambda 表示式的經驗，我們可以將其簡化成

array.forEach { println(it) }

2. 使用 雙冒號(::) 操作符來獲取函式的引用

:: 操作符常用於

1. 獲取KClass引用
2. 獲取函式引用
3. 獲取屬性引用
4. 獲取建構函式引用獲取KClass引用

• 所以上面的語句還可以寫作

array.forEach(::println)

這裡的函式引用引用的是包級函式，此外還有另外兩種：

• 使用類名呼叫（這種方式有一個隱含引數，就是呼叫者自己）

println(array.size) // 7
val newArray = array.filter(String::isNotEmpty)
print(newArray.size) // 6

• 再一個就是利用例項來呼叫

class MyPrint {
    fun out(any: Any) {
        println(any)
    }
}

val myPrint = MyPrint()
array.forEach(myPrint::out)

2. 常見的高階函式

forEach / map / flatMap

1. 假設有一個整形的 List，需要將 List 中的每一個元素擴大3被得到一個新的 List

val list = listOf(1, 2, 3, 4, 5, 6)
val newList = ArrayList<Int>()
list.forEach{
    var item = it*3
    newList.add(item)
}

2. 這裡，我們可以用 map 來簡化處理

val list = listOf(1, 2, 3, 4, 5, 6)
val newList = list.map { it * 3 }

3. flatMap

val list = listOf(7..14, 2..5, 10..17)

val flatList = list.flatMap { it }

val flatList = list.flatMap {
    it.map { "No. $it" }
}

val flatList = list.flatMap { itRange ->
    itRange.map { itItem ->
        "No. $itItem"
    }
}

4. reduce

• 利用 reduce 求 1..100 的和

println((1..100).reduce { acc, s -> acc + s }) //5050

• 利用 reduce 求 10 的階乘

println((1..10).reduce { acc, s -> acc * s }) //3628800

• 利用 reduce 求 0..10 的階乘

fun factorial(n: Int): Int {
    if (0 == n) {
        return 1
    }
    return (1..n).reduce { acc, i -> acc * i }
}

(0..10).map(::factorial).forEach(::println)

結果

1
1
2
6
24
120
720
5040
40320
362880
3628800

5. fold 帶有初始值的 reduce

println((0..10).map(::factorial).reduce { acc, i -> acc+i }) // 4037914
println((0..10).map(::factorial).fold(1) { acc, i -> acc+i }) // 4037915

• 利用 fold 拼接字串

println((0..10).map(::factorial).fold(StringBuilder()) { acc, i -> acc.append(i).append(",") })
// 1,1,2,6,24,120,720,5040,40320,362880,3628800,

println((0..10).map(::factorial).foldIndexed(StringBuilder()) { index,acc, i -> acc.append(index).append("->").append(i).append(",") })
0->1,1->1,2->2,3->6,4->24,5->120,6->720,7->5040,8->40320,9->362880,10->3628800,

• 利用 foldRight 倒序拼接字串

println((0..10).map(::factorial).foldRight(StringBuilder()) { i,acc -> acc.append(i).append(",") })
// 3628800,362880,40320,5040,720,120,24,6,2,1,1,

println((0..10).map(::factorial).foldRightIndexed(StringBuilder()) {index, i,acc -> acc.append(index).append("->").append(i).append(",") })
10->3628800,9->362880,8->40320,7->5040,6->720,5->120,4->24,3->6,2->2,1->1,0->1,

6. filter

保留 0..10 階乘結果為奇數的結果

println((0..10).map(::factorial).filter { it % 2 == 1 }) // [1, 1]

保留 0..10 階乘結果索引是奇數位的結果

println((0..10).map(::factorial).filterIndexed { index, i -> index % 2 == 1 }) // [1, 6, 120, 5040, 362880]

7. takeWhile

取出陣列中奇數值，一旦遇到偶數，停止取值

val listB = listOf(1, 3, 5, 6, 7, 8, 9, 10, 13)
println(listB.takeWhile { it % 2 == 1 }) // [1, 3, 5]

在上述要求上，倒序取值

println(listB.takeLastWhile { it % 2 == 1 }) // [13]

8. let apply

data class Person(var name: String, var age: Int) {
    fun work() {
        println("$name is working!")
    }
}

fun findPerson(age: Int): Person? {
    if (age <= 0) {
        return null
    }
    return Person("Tom", 18)
}

findPerson(-1)?.let { person ->
    person.work()
    println(person.age)
}
findPerson(-1)?.apply {
    work()
    println(age)
}

9. whit use

模擬讀取檔案

val br = BufferedReader(FileReader("hello.txt"))
with(br) {
    var line: String?
    while (true) {
        line = readLine() ?: break
        println(line)
    }
    close()
}

BufferedReader(FileReader("hello.txt")).use {
    var line: String?
    while (true) {
        line = it.readLine() ?: break
        println(line)
    }
}

1. 這裡需要使用 it 做指代；
2. 使用 use，可省略 close() 函式；