（三）Kotlin 高阶函数

2018-12-13 本文已影响0人 onestravel

一、基本概念

传入或者返回函数的函数
函数引用 ::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 高阶函数

一、基本概念

二、常见高阶函数（forEach/map/flatMap）

三、尾递归优化

四、闭包

五、函数复合

六、Currying (科理化)

七、偏函数

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

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

猜你喜欢

热点阅读