Kotlin实战指南八：高阶函数

赵彦军

已于 2023-02-22 20:44:52 修改

阅读量1k

点赞数

分类专栏： Kotlin实战指南文章标签： kotlin zhaoyanjun 赵彦军 kotlin高阶函数 Android kotlin

于 2019-03-31 23:25:25 首次发布

本文链接：https://blog.csdn.net/zhaoyanjun6/article/details/87969098

版权

android 同时被 2 个专栏收录

122 篇文章 21 订阅

订阅专栏

Kotlin实战指南

31 篇文章 54 订阅

订阅专栏

转载请标明出处：https://blog.csdn.net/zhaoyanjun6/article/details/87969098
本文出自【赵彦军的博客】

any

any 只要有一个符合就返回true

val list = listOf<Int>(1,2,3,4,5,6)

//只要list 中有一个是大于3就返回true
val any= list.any { it>3 }

all

all 所有条件符合才返回true

val list = listOf<Int>(1,2,3,4,5,6)

// list 中所有元素大于3就返回true
val any= list.all { it>3 }

count

count 返回符合条件的数目

val list = listOf<Int>(1,2,3,4,5,6)

var any =  list.count { it > 5 }

none

none 如果没有任何元素与给定的函数匹配，则返回true

val list = listOf<Int>(1,2,3,4,5,6)

var any =  list.none { it > 5 }

max

max 返回最大的值，如果没有则返回null ,min同理

val list = listOf<Int>(1,2,3,4,5,6)
var result = list.max()

min

min 返回最小的值，如果没有则返回null

val list = listOf<Int>(1,2,3,4,5,6)
var result = list.min()

sum

sum 返回数据相加总数

val list = listOf<Int>(1,2,3,4,5,6)
var result = list.sum()

forEachIndexed

forEachIndexed 与foreach相同，但是可以得到index

drop 从前面丢弃元素

val list = listOf<Int>(1,2,3,4,5,6)
var result = list.drop(2) 
//丢弃前两个元素，结果为：[3, 4, 5, 6]

dropLast 从后面丢弃元素

val list = listOf<Int>(1,2,3,4,5,6)
var result = list.dropLast(2)
//丢弃后两个元素，结果为：[1,2,3, 4]

groupBy 分组

groupBy 根据函数将集合分组，返回map类型对象

val list = listOf<Int>(1,2,3,4,5,6,7,8,9,10)

//把 list 分为偶数和奇数
var result = list.groupBy { it % 2 == 0}
Log.e("zhaoyanjun:", "" + result)

结果:返回的是 map 对象

{false=[1, 3, 5, 7, 9], true=[2, 4, 6, 8, 10]}

filter

过滤list，符合过滤条件的就是过滤结果

var list = mutableListOf(1, 2, 3, 4)
        
var list2 = list.filter { it ->
      it > 2  
 }

或者可以更短:

var list = mutableListOf(1, 2, 3, 4)

var list2 = list.filter { 
      it > 2
}

list2的结果是：

[3,4]

filterNot

把符合条件的过滤掉，剩下的是结果。这个操作和 filter 相反。

例子1：操作List

var list = mutableListOf<Int>(1, 2, 3)
var list2 = list.filterNot {  it > 2}

list2结果是:

[1,2]

例子2：操作Map

var map = mutableMapOf<Int, String>()
map.put(0, "a")
map.put(1, "b")
map.put(2, "c")

var map2 = map.filterNot { it.key ==2 }

map2的结果是：

{0=a, 1=b}

take、takeLast

take是从集合中取前几个元素
takeLast是从集合中取后几个元素

val list = mutableListOf<Int>(1,2,3,4)

var list2 = list.take(3)    //结果：[1, 2, 3]
var list3 = list.takeLast(2)  //结果：[2, 3, 4]

sortedBy 排序

在 java 中，我们要对一个list排序，需要写很多代码，但是在 kotlin 中，就简单很多了。

首先我们定义一个 User 类，这个类只有两个字段，分别是 id，name ，代码如下：

class User(var id: Int, var name: String)

//定义三个 User 变量
var u1 = User(1,"张三")
var u2 = User(3,"李四")
var u3 = User(2,"王五")

//用list把三个变量装起来
var list = listOf<User>(u1,u2,u3)

//对 id 字段进行排序，并把排序的结果赋值给 list2
var list2 = list.sortedBy { it.id }

//输出list2
list2.forEach {
    Log.e("zhaoyanjun:", ""+ it.id + "" + it.name)
}

结果如下：

com.kotlin E/zhaoyanjun:: 1张三
com.kotlin E/zhaoyanjun:: 2王五
com.kotlin E/zhaoyanjun:: 3李四

需要注意的是：

1、使用 list.sortedBy 对 list 排序，但是 list 的顺序并没有发生就改变，还是原来的顺序。
2、sortedBy() 方法为顺序排序，如果想要逆序排序，可以使用 sortedByDescending() 方法。

map 数据结构变化

我们现在有一个需求，需要把所有的用户的用户名存在一个 list 里面，就可以用 map 操作符。

var listName = list.map { it.name }

Log.e("zhaoyanjun:", "" + listName)

输出结果：

[张三, 李四, 王五]

除此之外，还可以连续操作。比如，我们把用户名字中最后一个取出来。

var listName = list.map { it.name }
                   .takeLast(1)

Log.e("zhaoyanjun:", "" + listName)

输出结果：

[王五]

常用操作符

Kotlin 的操作符跟 RxJava 基本一致，不需要额外记忆。

下标操作类

contains —— 判断是否有指定元素
elementAt —— 返回对应的元素，越界会抛IndexOutOfBoundsException
firstOrNull —— 返回符合条件的第一个元素，没有返回null
lastOrNull —— 返回符合条件的最后一个元素，没有返回null
indexOf —— 返回指定元素的下标，没有返回-1
singleOrNull —— 返回符合条件的单个元素，如有没有符合或超过一个，返回null

判断类

any —— 判断集合中是否有满足条件的元素
all —— 判断集合中的元素是否都满足条件
none —— 判断集合中是否都不满足条件，是则返回true
count —— 查询集合中满足条件的元素个数
reduce —— 从第一项到最后一项进行累计

过滤类

filter —— 过滤掉所有满足条件的元素
filterNot —— 过滤所有不满足条件的元素
filterNotNull —— 过滤NULL
take —— 返回前 n 个元素

转换类

map —— 转换成另一个集合（与上面我们实现的 convert 方法作用一样）;
mapIndexed —— 除了转换成另一个集合，还可以拿到Index(下标);
mapNotNull —— 执行转换前过滤掉为 NULL 的元素
flatMap —— 自定义逻辑合并两个集合；
groupBy —— 按照某个条件分组，返回Map；

排序类

reversed —— 反序
sorted —— 升序
sortedBy —— 自定义排序
sortedDescending —— 降序

自定义高阶函数

定义高阶函数

    fun run(block: () -> Unit) {

    }

定义高阶变量

class My {

    private var mListener: ((Int, String) -> Unit)? = null

    fun setListener(listener: ((Int, String) -> Unit)?) {
        mListener = listener
    }
}

定义高阶函数2

val sum: (Int, Int) -> Int = { x, y -> x + y }
//等价
val sum2 = { x: Int, y: Int -> x + y }

定义suspend 高阶函数

fun run(block: suspend (Int) -> Unit): Job {
    return GlobalScope.launch(Dispatchers.Main) {
        block(2)
    }
}

suspend fun run2() {
    withContext(Dispatchers.IO) {

    }
}

fun test() {
    run {
        //run2是挂起函数，可以写在这里，是因为 run 函数的 block 是挂起函数
        run2()
    }
}

定义suspend 高阶函数，返回 CoroutineScope

fun launchIO(block: suspend CoroutineScope.() -> Unit): Job {
    return GlobalScope.launch(Dispatchers.IO) {
        block()
    }
}

fun test() {
    launchIO { 
        withContext(Dispatchers.IO){
            
        }
    }
}

常用高阶函数定义方法

    fun test2(test: Int, block: () -> Unit) {
        block()
    }

    fun <T> T.test22(block: () -> T): T {
        return block()
    }

    fun <T> T.test26(block: T.() -> Unit) {
        block()
    }

    fun <T> T.test23(block: (T) -> Unit): T {
        return this
    }

    fun <T, R> T.test3(block: (T) -> R): R {
        var t = block(this)
        return t
    }

    fun <T, W> T.test4(block: (T) -> W): W {
        return block(this)
    }