（三）Kotlin 高阶函数

温馨提示

写博客是为了记录在开发过程中所涉及到的技术以及遇到的问题的解决，如果该博客对您有所帮助，希望可以点个关注；如果您对文章中的内容有什么不同的见解，欢迎留言进行讨论。谢谢！

一、基本概念

• 传入或者返回函数的函数
• 函数引用 ::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 { 
    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){
    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){
    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 Function3.curried()
    =fun(p1:P1)=fun(p2:P2)=fun(p3:P3)=this(p1,p2,p3)
    
fun main(args: Array){
    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 Function3.curried()
    =fun(p1:P1)=fun(p2:P2)=fun(p3:P3)=this(p1,p2,p3)
    
fun main(args: Array){
    val consoleLog = (::log.cueried())("Test out")(System.out)
    consoleLog("Hello 偏函数！")
}

上一篇：（二）Kotlin 面向对象

下一篇：（四）Kotlin 领域特定语言 DSL