kotlin 学习 -- 令人眼花缭乱的高阶函数

1 高阶函数

基本概念: 传入值或者返回值为函数的函数

1.1 传入值为函数

将一个函数作为参数传进函数当中,例子如下:

fun main(args:Array<String>) {
        args.forEach(::println) //函数引用
}

inline fun println(message: Any?) {
    System.out.println(message)
}

inline fun <T> Array<out T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

在上面你的例子当值,函数forEach要求传入一个类型为T 返回值为Unit的函数参数
::println,表示一个函数的引用,调用args.forEach(::println),表示将println函数出入给forEach。

1.2 返回值为函数(闭包)

  • 支持函数式编程
  • 持有函数的状态
  • 函数内部可以定义函数/类
fun add(x: Int): (Int) -> Int {
    return fun(y: Int): Int {
        return x + y
    }
}
fun main() {
    var add2 = add(2)
    println(add2(10))
}

函数的定义方法可以传入函数,也可以返回函数,函数内的作用域包含了函数内的子函数跟子类等。 格式 : fun 方法名(形参:函数类型) 函数类型{} 函数类型基本写法: () -> Unit (多个参数) -> 返回类型

1.3 函数复合

  • f(g(x)) 函数传入函数
//定义两个函数
val add = { i: Int -> i + 5 }

val multiplyBy = { i: Int -> i * 2 }

fun main() {
    println(multiplyBy(add(9)))
}

上面的例子可以看出,将参数9传入add函数中得到一个Int返回值,再将其返回值作为参数传入multiplyBy当中,即为函数的复合,

//定义三个函数
val add5 = { i: Int -> i + 5 } //g(x)
val multiplyBy2 = { i: Int -> i * 2 } //f(x)
val sum = { q: Int, w: Int -> q + w } //m(x)

infix fun <P1, P2, R> Function1<P1, P2>.andThen(function: Function1<P2, R>): Function1<P1, R> {
    return fun(p1: P1): R {
        return function.invoke(this.invoke(p1))
    }
}


infix fun <P1,P2,R> Function1<P2,R>.compose(function:Function1<P1,P2>):Function1<P1,R>{
    return fun (p1:P1):R{
        return this.invoke(function.invoke(p1))
    }
}

fun <P1, P2, P3, R> Function2<P2, P3, R>.toAllSum(
    function: Function1<P1, P2>,
    function1: Function1<P2, P3>
): Function2<P1, P2, R> {
    return fun(p1: P1, p2: P2): R {
        return this.invoke(function.invoke(p1), function1.invoke(p2))
    }
}

fun main() {
    val add5AndMulti2 = add5 andThen multiplyBy2 
    val add5ComposeMulti2 = add5 compose multiplyBy2
    val sum = sum.toAllSum(add5, multiplyBy2)

    println(add5AndMulti2(10)) //f(g(x))
    println(add5ComposeMulti2(10))//g(f(x))
    println(sum(10,10))//m(f(x),g(x))
}

-----打印出来的Log
30
25
35

1.4 函数柯里化

柯里化是一个数学概念, 简单的来说,就是对于一个有多个参数的函数,转换成每次只接受一个参数的函数,最后输入结果。 Currying 的重要意义在于可以把函数完全变成「接受一个参数;返回一个值」的固定形式。

看代码:

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

fun main(args: Array<String>) {
    log("tag",System.out,"helloWorld")
    log("tag")(System.out)("helloWorld1")
}

1.5 偏函数

对一个多参数的函数,通过指定其中的一部分参数后得到的仍然是一个函数,那么这个函数就是原函数的一个偏函数了。

看个🌰:

 fun <P1, P2, R> Function2<P1, P2, R>.partial1(p1: P1) = fun(p2: P2) = this(p1, p2) 
 fun <P1, P2, R> Function2<P1, P2, R>.partial2(p2: P2) = fun(p1: P1) = this(p1, p2)

fun main(args: Array<String>) {
    val addOne = add.partial1(1)
    val addTwo = add.partial2("2")
    addOne("2").println()
    addTwo(3).println()
}

val add = {a:Int, b: String -> "$a$b"}

在上面的例子中,函数addOne和addTwo分别为partial1和partial2的偏函数

1.6 DSL

DSL(domain specific language),即领域专用语言:专门解决某一特定问题的计算机语言,比如大家耳熟能详的 SQL 和正则表达式。

kotlin中实现DSL的方式,实际上是使用了kotlin的lamda表达式和kotlin的扩展方法实现的,让我们看个例子:

class Linear {
    fun fragme(init: Fragme.() -> Unit) {
        Fragme().init()
    }

    fun text(init: Text.() -> Unit) {
        Text().init()
    }
}

class Fragme {
    fun text(init: Text.() -> Unit) {
        Text().init()
    }
}

class Text {}

fun linear(init: Linear.() -> Unit) {
    Linear().init()
}

fun run(){
    linear { 
        fragme { 
            text {  }
        }
        text {  }
    }
}

2.高阶函数-集合的变换

平时在开发业务代码的时候,会经常遇到对结合进行增删改查操作,在kotlin中提供了大量的集合操作符供我们使用.

2.1 转化类

2.1.1 集合转数组

当我们声明一个集合,可以把这个集合根据调用集合类相应的高阶函数来转换成相应的数组。集合类提供了toIntArray()、toDoubleArray()、toFloatArray()、toBetArray()等高阶函数去处理。

下面看一个转IntArray的源码:

public fun Collection<Int>.toIntArray(): IntArray {
    val result = IntArray(size)
    var index = 0
    for (element in this)
        result[index++] = element
    return result
}

从源码可以看出集合的toIntArray函数,是先创建一个和集合长度相等数组,然后遍历集合赋值给数组,最后返回该数组

例子:

fun listToArray(){
    val list = listOf<Int>(1,2,3,4,5,6)         // 声明一个Int类型的List
    val listArray = list.toIntArray()           // 转换

    println(list.javaClass.toString())          // 打印list的类型
    println(listArray.javaClass.toString())     // 打印listArray的类型
    println(listArray[1])
}

2.1.2 转换为集合

我们知道在Kotlin中,集合可分为不可变集合与可变集合。我们声明一个集合或者数组,可以转换成相应类型的集合。调用toXXX()转换成不可变集合。调用toMutableXXX()转换为可变集合。集合类提供了toList()、toMutableList()、toSet()、toMutableSet()、toHashSet()、toMap()等高阶函数去处理。同理也是从源码的角度去分析。

源码:Iterable转list

public fun <T> Iterable<T>.toList(): List<T> {
    if (this is Collection) {
        return when (size) {
            0 -> emptyList()
            1 -> listOf(if (this is List) get(0) else iterator().next())
            else -> this.toMutableList()
        }
    }
    return this.toMutableList().optimizeReadOnlyList()
}

实例:

// 数组转集合
fun arrayToList() {
    val arr = arrayOf(1,3,5,7,9)
    val list = arr.toList()
    println("变量arr的类型为:${arr.javaClass}")
    println("变量list的类型为:${list.javaClass}")
    println(list[1])
}

// 集合转集合,这里用Set转List

fun listToList(){
    val set = setOf(1)
    val setTolist = set.toList()
    
    println("变量set的类型为:${set.javaClass}")
    println("变量setTolist的类型为:${setTolist.javaClass}")
    println(setTolist[0])
}

2.2 操作类

关于集合操作类的函数大致分为六类,他们几乎上囊括了源码中实现的操作方法.这些方法基本都存在于_Collections.kt这个文件中

2.2.1 元素操作符

元素操作符包括以下方法:

  • contains(元素) : 检查集合中是否包含指定的元素,若存在则返回true,反之返回false
  • elementAt(index) : 获取对应下标的元素。若下标越界,会抛出IndexOutOfBoundsException(下标越界)异常,同get(index)一样
  • elementAtOrElse(index,{...}) : 获取对应下标的元素。若下标越界,返回默认值,此默认值就是你传入的下标的运算值
  • elementAtOrNull(index) : 获取对应下标的元素。若下标越界,返回null
  • first() : 获取第一个元素,若集合为空集合,这会抛出NoSuchElementException异常
  • first{} : 获取指定元素的第一个元素。若不满足条件,则抛出NoSuchElementException异常
  • firstOrNull() : 获取第一个元素,若集合为空集合,返回null
  • firstOrNull{} : 获取指定元素的第一个元素。若不满足条件,返回null
  • getOrElse(index,{...}) : 同elementAtOrElse一样
  • getOrNull(index) : 同elementAtOrNull一样
  • last() : 同first()相反
  • lastOrNull() : 同firstOrNull{}相反
  • indexOf(元素) : 返回指定元素的下标,若不存在,则返回-1
  • indexOfFirst{...} : 返回第一个满足条件元素的下标,若不存在,则返回-1
  • indexOfLast{...} : 返回最后一个满足条件元素的下标,若不存在,则返回-1
  • single() : 若集合的长度等于0,则抛出NoSuchElementException异常,若等于1,则返回第一个元素。反之,则抛出IllegalArgumentException异常
  • single{} : 找到集合中满足条件的元素,若元素满足条件,则返回该元素。否则会根据不同的条件,抛出异常。这个方法慎用
  • singleOrNull() : 若集合的长度等于1,则返回第一个元素。否则,返回null
  • singleOrNull{} : 找到集合中满足条件的元素,若元素满足条件,则返回该元素。否则返回null
  • forEach{...} : 遍历元素。一般用作元素的打印
  • forEachIndexed{index,value} : 遍历元素,可获得集合中元素的下标。一般用作元素以及下标的打印
  • componentX() : 这个函数x代表获取第几个元素等价于list[x]

下面看看例子:

val list = listOf("kotlin","Android","Java","PHP","Python","IOS")

println("  ------   contains -------")
println(list.contains("JS"))

println("  ------   elementAt -------")

println(list.elementAt(2))
println(list.elementAtOrElse(10,{it}))
println(list.elementAtOrNull(10))

println("  ------   get -------")
println(list.get(2))
println(list.getOrElse(10,{it}))
println(list.getOrNull(10))

println("  ------   first -------")
println(list.first())
println(list.first{ it == "Android" })
println(list.firstOrNull())
println(list.firstOrNull { it == "Android" })

println("  ------   last -------")
println(list.last())
println(list.last{ it == "Android" })
println(list.lastOrNull())
println(list.lastOrNull { it == "Android" })

println("  ------   indexOf -------")
println(list.indexOf("Android"))
println(list.indexOfFirst { it == "Android" })
println(list.indexOfLast { it == "Android" })

println("  ------   single -------")
val list2 = listOf("list")
println(list2.single())     // 只有当集合只有一个元素时,才去用这个函数,不然都会抛出异常。
println(list2.single { it == "list" }) //当集合中的元素满足条件时,才去用这个函数,不然都会抛出异常。若满足条件返回该元素
println(list2.singleOrNull()) // 只有当集合只有一个元素时,才去用这个函数,不然都会返回null。
println(list2.singleOrNull { it == "list" }) //当集合中的元素满足条件时,才去用这个函数,不然返回null。若满足条件返回该元素

println("  ------   forEach -------")
list.forEach { println(it) }
list.forEachIndexed { index, it -> println("index : $index \t value = $it") }

println("  ------   componentX -------")
println(list.component1())  // 等价于`list[0]  <=> list.get(0)`
println(list.component2())  // 等价于`list[1]  <=> list.get(1)`
println(list.component3())  // 等价于`list[2]  <=> list.get(2)`
println(list.component4())  // 等价于`list[3]  <=> list.get(3)`
println(list.component5())  // 等价于`list[4]  <=> list.get(4)`

2.2.2 顺序操作符

顺序操作符包括:

  • reversed() : 反序。即和初始化的顺序反过来。
  • sorted() : 自然升序。
  • sortedBy{} : 根据条件升序,即把不满足条件的放在前面,满足条件的放在后面
  • sortedDescending() : 自然降序。
  • sortedByDescending{} : 根据条件降序。和sortedBy{}相反

例子:

val list1 = listOf(-1,-3,1,3,5,6,7,2,4,10,9,8)

// 反序
println(list1.reversed())

// 升序
println(list1.sorted())

// 根据条件升序,即把不满足条件的放在前面,满足条件的放在后面
println(list1.sortedBy { it % 2 == 0})

// 降序
println(list1.sortedDescending())

// 根据条件降序,和`sortedBy{}`相反
println(list1.sortedByDescending { it % 2 == 0 })

2.2.3 映射操作符

映射操作符包括:

  • map{...} : 把每个元素按照特定的方法进行转换,组成一个新的集合
  • mapNotNull{...} : 同map{}函数的作用相同,只是过滤掉转换之后为null的元素
  • mapIndexed{index,result} : 把每个元素按照特定的方法进行转换,只是其可以操作元素的下标(index),组成一个新的集合。
  • mapIndexedNotNull{index,result} : 同mapIndexed{}函数的作用相同,只是过滤掉转换之后为null的元素
  • flatMap{...} : 根据条件合并两个集合,组成一个新的集合。
  • groupBy{...} : 分组。即根据条件把集合拆分为为一个Map<K,List<T>>类型的集合。

具体看实例:

val list1 = listOf("kotlin","Android","Java","PHP","JavaScript")

println(list1.map { "str-".plus(it) })

println(list1.mapNotNull { "str-".plus(it) })

println(list1.mapIndexed { index, str ->
    index.toString().plus("-").plus(str)
})

println(list1.mapIndexedNotNull { index, str ->
    index.toString().plus("-").plus(str)
})

println( list1.flatMap { listOf(it,"new-".plus(it)) })

println(list1.groupBy { if (it.startsWith("Java")) "big" else "latter" })

2.2.4 过滤操作符

过滤操作符包括:

  • filter{...} : 把不满足条件的元素过滤掉
  • filterIndexed{...} : 和filter{}函数作用类似,只是可以操作集合中元素的下标(index)
  • filterNot{...} : 和filter{}函数的作用相反
  • filterNotNull() : 过滤掉集合中为null的元素
  • take(num) : 返回集合中前num个元素组成的集合
  • takeWhile{...} : 循环遍历集合,从第一个元素开始遍历集合,当第一个出现不满足条件元素的时候,退出遍历。然后把满足条件所有元素组成的集合返回
  • takeLast(num) : 返回集合中后num个元素组成的集合
  • takeLastWhile{...} : 循环遍历集合,从最后一个元素开始遍历集合,当第一个出现不满足条件元素的时候,退出遍历。然后把满足条件所有元素组成的集合返回。
  • drop(num) : 过滤集合中前num个元素
  • dropWhile{...} : 相同条件下,和执行takeWhile{...}函数后得到的结果相反
  • dropLast(num) : 过滤集合中后num个元素
  • dropLastWhile{...} : 相同条件下,和执行takeLastWhile{...}函数后得到的结果相反
  • distinct() : 去除重复元素
  • distinctBy{...} : 根据操作元素后的结果去除重复元素
  • slice : 过滤掉所有不满足执行下标的元素

例子:

val list1 = listOf(-1,-3,1,3,5,6,7,2,4,10,9,8)
val list2 = listOf(1,3,4,5,null,6,null,10)
val list3 = listOf(1,1,5,2,2,6,3,3,7,4,4,8)

println("  ------   filter -------")
println(list1.filter { it > 1  })
println(list1.filterIndexed { index, result ->
    index < 5 && result > 3
})
println(list1.filterNot { it > 1 })
println(list2.filterNotNull())

println("  ------   take -------")
println(list1.take(5))
println(list1.takeWhile { it < 5 })
println(list1.takeLast(5))
println(list1.takeLastWhile { it > 5 })

println("  ------   drop -------")
println(list1.drop(5))
println(list1.dropWhile { it < 5 })
println(list1.dropLast(5))
println(list1.dropLastWhile { it > 5 })

println("  ------   distinct -------")
println(list3.distinct())
println(list3.distinctBy { it + 2 })

println("  ------   slice -------")
println(list1.slice(listOf(1,3,5,7)))
println(list1.slice(IntRange(1,5)))

2.2.5 统计操作符

统计操作符包括:

  • any() : 判断是不是一个集合,若是,则在判断集合是否为空,若为空则返回false,反之返回true,若不是集合,则返回hasNext
  • any{...} : 判断集合中是否存在满足条件的元素。若存在则返回true,反之返回false
  • all{...} : 判断集合中的所有元素是否都满足条件。若是则返回true,反之则返回false
  • none() : 和any()函数的作用相反
  • none{...} : 和all{...}函数的作用相反
  • max() : 获取集合中最大的元素,若为空元素集合,则返回null
  • maxBy{...} : 获取方法处理后返回结果最大值对应那个元素的初始值,如果没有则返回null
  • min() : 获取集合中最小的元素,若为空元素集合,则返回null
  • minBy{...} : 获取方法处理后返回结果最小值对应那个元素的初始值,如果没有则返回null
  • sum() : 计算出集合元素累加的结果
  • sumBy{...} : 根据元素运算操作后的结果,然后根据这个结果计算出累加的值
  • sumByDouble{...} : 和sumBy{}相似,不过sumBy{}是操作Int类型数据,而sumByDouble{}操作的是Double类型数据
  • average() : 获取平均数
  • reduce{...} : 从集合中的第一项到最后一项的累计操作
  • reduceIndexed{...} : 和reduce{}作用相同,只是其可以操作元素的下标(index)
  • reduceRight{...} : 从集合中的最后一项到第一项的累计操作
  • reduceRightIndexed{...} : 和reduceRight{}作用相同,只是其可以操作元素的下标(index)
  • fold{...} : 和reduce{}类似,但是fold{}有一个初始值
  • foldIndexed{...} : 和reduceIndexed{}类似,但是foldIndexed{}有一个初始值
  • foldRight{...} : 和reduceRight{}类似,但是foldRight{}有一个初始值
  • foldRightIndexed{...} : 和reduceRightIndexed{}类似,但是foldRightIndexed{}有一个初始值

例子:

val list1 = listOf(1,2,3,4,5)

println("  ------   any -------")
println(list1.any())
println(list1.any{it > 10})

println("  ------   all -------")
println(list1.all { it > 2 })

println("  ------   none -------")
println(list1.none())
println(list1.none{ it > 2})

println("  ------   max -------")
println(list1.max())
println(list1.maxBy { it + 2 })

println("  ------   min -------")
println(list1.min())        // 返回集合中最小的元素
println(list1.minBy { it + 2 })

println("  ------   sum -------")
println(list1.sum())
println(list1.sumBy { it + 2 })
println(list1.sumByDouble { it.toDouble() })

println(" ------  average -----")
println(list1.average())

println("  ------   reduce  -------")
println(list1.reduce { result, next -> result  + next})
println(list1.reduceIndexed { index, result, next ->
    index + result + next
})
println(list1.reduceRight { result, next -> result  + next })
println(list1.reduceRightIndexed {index, result, next ->
    index + result + next
})

println("  ------   fold  -------")
println(list1.fold(3){result, next -> result  + next})
println(list1.foldIndexed(3){index,result, next ->
    index + result  + next
})
println(list1.foldRight(3){result, next -> result  + next})
println(list1.foldRightIndexed(3){index,result, next ->
    index + result  + next
})
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 206,602评论 6 481
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 88,442评论 2 382
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 152,878评论 0 344
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 55,306评论 1 279
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 64,330评论 5 373
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 49,071评论 1 285
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 38,382评论 3 400
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 37,006评论 0 259
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 43,512评论 1 300
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,965评论 2 325
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,094评论 1 333
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 33,732评论 4 323
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 39,283评论 3 307
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,286评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,512评论 1 262
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 45,536评论 2 354
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 42,828评论 2 345

推荐阅读更多精彩内容