文章目录

温馨提示

一、基本概念
二、常见高阶函数（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 1return (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 的阶乘进行求和并加上初始值 5println((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 高阶函数

文章目录

温馨提示

一、基本概念

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

三、尾递归优化

四、闭包

五、函数复合

六、Currying (科理化)

七、偏函数

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

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

更多相关文章

随机推荐