文章目錄

• 一、基本概念
• 二、常見高階函式（forEach/map/flatMap）
• 三、尾遞迴優化
• 四、閉包
• 五、函式複合
• 六、Currying (科理化)
• 七、偏函式
• 上一篇：[（二）Kotlin 面向物件](https://blog.csdn.net/qq_20538515/article/details/84987919)
• 下一篇：[（四）Kotlin 領域特定語言 DSL](https://blog.csdn.net/qq_20538515/article/details/84988699)

一、基本概念

• 傳入或者返回函式的函式
• 函式引用 ::println
• 帶有 Receiver 的引用 pdfPrinter::println

二、常見高階函式（forEach/map/flatMap）

• forEach : 迭代/遍歷陣列/list

//forEach函式使用的一般結構
object.forEach{
    //todo
}

例：
val list = listOf(1,3,5,10,18,36,2,9)
list.forEach(::println)

• map : 接受一個lambda表示式，並且有返回值，形成一個新的list

//map函式使用的一般結構
object.map{
    //todo
}

例：
val newList = list.map{
    it * 2 + 3//相當於返回值
}

val newList2 = list.map(Int::toDouble)

• flatMap : 集合資料進行合併成一個集合

//map函式使用的一般結構
object.flatMap {
    it
    //todo
}
或
object.flatMap {
    it.map {
        //todo
    }
}
        

例：
val list = listOf(
    1..20,
    2..15,
    100..166)
 val flatList = list.flatMap{
     it
 }   
 
  val flatList = list.flatMap{
     it.map{
         "No.$it"
     }
 } 

 

• reduce : 使用reduce對集合進行計算操作

//reduce函式使用的一般結構
object.reduce{acc,i -> 
    //acc 為累計的結果
    //acc todo
}

例：
list.reduce{acc,i -> acc + i}

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

//對0-6的數分別求階乘，並且打印出來
(0..6).map(::factorial).forEach(::println)

• fold : 使用fold對集合進行自定義計算

//fold函式使用的一般結構
object.fold([初始值]){acc,i ->
    //todo
}

例：
// 對0-6 的階乘進行求和並加上初始值 5
println((0..6).map(::factorial).fold(5){acc,i ->
 acc + i
})

//字串拼接
println((0..6).map(::factorial).fold(StringBuilder()){acc,i ->
 acc.append(i).append(",")
})

// 字串連線
println((0..6).joinToString(","))

• foldRight : 與fold不同的是順序相反

//foldRight函式使用的一般結構
object.foldRight([初始值]){i,acc ->
    //todo
}

例：

//字串拼接
println((0..6).map(::factorial).foldRight(StringBuilder()){i,acc ->
 acc.append(i).append(",")
})

• filter : 傳入Lambda 表示式為true是，保留該元素；使用filter對集合進行按條件過濾

//filter函式使用的一般結構
object.filter{
    //todo
}

例：
//給一個長度為 n 的陣列，每個元素都在 [1,n] 之間，要求找出 [1,n] 中沒有在數組裡出現的元素。
fun findDisappearNumbers(nums: IntArray): List<Int> { 
    val ifAppear = BooleanArray(nums.size + 1)
    nums.forEach { ifAppear[it] = true } 
    return ifAppear.mapIndexed { 
        index, boolean -> 
        if (boolean || index == 0) -1 else index 
    }.filter { it != -1 } 
} 

• takeWhile : 迴圈遍歷集合，直到第一個不滿足條件的資料時，停止迴圈

//takeWhile函式使用的一般結構
object.takeWhile{
    //todo
}

• let : let擴充套件函式的實際上是一個作用域函式，當你需要去定義一個變數在一個特定的作用域範圍內，let函式的是一個不錯的選擇；let函式另一個作用就是可以避免寫一些判斷null的操作。

//let函式使用的一般結構
object.let{
it.todo()//在函式體內使用it替代object物件去訪問其公有的屬性和方法
...
}

//另一種用途 判斷object為null的操作
object?.let{//表示object不為null的條件下，才會去執行let函式體
it.todo()
}

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

fun findPerson():Person?{
    return null
}

fun main(args: Array<String>){
    findPerson()?.let{person -> 
        person.work()
        println(person.age)
    }
}

• apply : apply一般用於一個物件例項初始化的時候，需要對物件中的屬性進行賦值;一般可用於多個擴充套件函式鏈式呼叫 ;資料model多層級包裹判空處理的問題

//apply函式使用的一般結構
object.apply{
//todo
}

//例：
//1、
data class Person(val name: String,val age:Int){
    fun work(){
        println("$name is working!!!")
    }
}

fun findPerson():Person?{
    return null
}

fun main(args: Array<String>){
    findPerson()?.apply{
        work()
        println(age)
    }
}

//2、
mSectionMetaData?.apply{

//mSectionMetaData不為空的時候操作mSectionMetaData

}?.questionnaire?.apply{

//questionnaire不為空的時候操作questionnaire

}?.section?.apply{

//section不為空的時候操作section

}?.sectionArticle?.apply{

//sectionArticle不為空的時候操作sectionArticle

}

• with : 適用於呼叫同一個類的多個方法時，可以省去類名重複，直接呼叫類的方法即可

//with函式使用的一般結構
with(object){
   //todo
 }
 
 例：
 val br = Buffered

• run ： run函式是let,with兩個函式結合體，準確來說它彌補了let函式在函式體內必須使用it引數替代物件，在run函式中可以像with函式一樣可以省略，直接訪問例項的公有屬性和方法，另一方面它彌補了with函式傳入物件判空問題，在run函式中可以像let函式一樣做判空處理

//run函式使用的一般結構
object.run{
//todo
}

• also : 適用於let函式的任何場景，also函式和let很像，只是唯一的不同點就是let函式最後的返回值是最後一行的返回值而also函式的返回值是返回當前的這個物件。一般可用於多個擴充套件函式鏈式呼叫

//also函式使用的一般結構
object.also{
//todo
}

• use : use函式作用於現實了Closeable介面的類，比如檔案io操作

//use函式使用的一般結構
object.use{
    //todo
}

例：
var l = BufferedReader(FileReader("123.txt")).use { 
    var line: String = "" 
    while (true){ 
        line += it.readLine()?: break 
    } 
    line
} 
println(l) 

三、尾遞迴優化

• 遞迴的一種特殊形式
• 呼叫自身後無其他操作
• tailrec 關鍵字提示編譯器尾遞迴優化
• 尾遞迴與迭代的關係，尾遞迴一般情況下可以直接轉換為迭代

四、閉包

• 閉包就是函式的執行環境
• 持有函式執行狀態
• 函式內部可以定義函式
• 函式內部也可以定義類

五、函式複合

• 函式複合就是f(g(x))的形式的函式

六、Currying (科理化)

• 就是多元函式變成一元函式呼叫鏈

fun log(tag:String,target:OutputStream,message:Any?){
    target.write("[$tag]: $message\n".toByteArray())
}

fun curriedLog(tag:String):(target:OutputStream) -> (message:Any?){
    //todo
}
//fun log(tag:String)
//    =fun (target:OutputStream)
//    =(message:Any?)
//    =target.write("[$tag]: $message\n".toByteArray())
    
fun<P1,P2,P3,R> Function3<P1,P2,P3,R>.curried()
    =fun(p1:P1)=fun(p2:P2)=fun(p3:P3)=this(p1,p2,p3)
    
fun main(args: Array<String>){
    log("Test",System.out,"Hello World！")
   // log("Test")(System.out)("Hello World Currying")
    ::log.curried()("Test")(System.out)("Hello World Currying")
}

七、偏函式

• 傳入部分引數之後得到的新函式就是偏函式

fun log(tag:String,target:OutputStream,message:Any?){
    target.write("[$tag]: $message\n".toByteArray())
}

fun<P1,P2,P3,R> Function3<P1,P2,P3,R>.curried()
    =fun(p1:P1)=fun(p2:P2)=fun(p3:P3)=this(p1,p2,p3)
    
fun main(args: Array<String>){
    val consoleLog = (::log.cueried())("Test out")(System.out)
    consoleLog("Hello 偏函式！")
}

上一篇：（二）Kotlin 面向物件

下一篇：（四）Kotlin 領域特定語言 DSL