Kotlin实战指南八：高阶函数_kotlin map.filter null

转载请标明出处：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 }  
1
2
3
4

all

all 所有条件符合才返回true

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

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

count

count 返回符合条件的数目

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

var any =  list.count { it > 5 }
1
2
3

none

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

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

var any =  list.none { it > 5 }
1
2
3

max

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

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

min

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

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

sum

sum 返回数据相加总数

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

forEachIndexed

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

drop 从前面丢弃元素

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

dropLast 从后面丢弃元素

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

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)

1
2
3
4
5
6

结果:返回的是 map 对象

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

filter

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

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

或者可以更短:

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

var list2 = list.filter { 
      it > 2
}
1
2
3
4
5

list2的结果是：

[3,4]

filterNot

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

例子1：操作List

var list = mutableListOf<Int>(1, 2, 3)
var list2 = list.filterNot {  it > 2}
1
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 }
1
2
3
4
5
6

map2的结果是：

{0=a, 1=b}

更多操作 filterKeys、filterValues

 var map = mutableMapOf<Int, String>()

var map2 = map.filterKeys { it == 3 }  //过滤key
val map3 = map.filterValues { it == "a" } //过滤 value
1
2
3
4

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]
1
2
3
4

sortedBy 排序

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

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

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

//定义三个 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)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果如下：

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

需要注意的是：

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

map 数据结构变化

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

var listName = list.map { it.name }

Log.e("zhaoyanjun:", "" + listName)
1
2
3

输出结果：

[张三, 李四, 王五]
1

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

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

Log.e("zhaoyanjun:", "" + listName)
1
2
3
4

输出结果：

[王五]
1

常用操作符

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) {

    }
1
2
3

定义高阶变量

class My {

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

    fun setListener(listener: ((Int, String) -> Unit)?) {
        mListener = listener
    }
}
1
2
3
4
5
6
7
8

定义高阶函数2

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

定义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()
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

定义suspend 高阶函数，返回 CoroutineScope

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

fun test() {
    launchIO { 
        withContext(Dispatchers.IO){
            
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

常用高阶函数定义方法

    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)
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

---

个人微信号：zhaoyanjun125 , 欢迎关注