Kotlin中集合相关的操作符分为下述六类：
总数操作符、过滤操作符、映射操作符、顺序操作符、生产操作符、元素操作符
1、总数操作符
| 操作符 | 作用 |
|---|---|
any() | 判断是不是一个集合，若是，则在判断集合是否为空，若为空则返回false,反之返回true,若不是集合，则返回hasNext |
any{...} | 判断集合中是否存在满足条件的元素。若存在则返回true,反之返回false |
all{...} | 判断集合中的所有元素是否都满足条件。若是则返回true,反之则返回false |
none() | 如果没有任何元素与指定的函数条件匹配，则返回true。 |
none{...} | 如果没有任何元素与指定的函数条件匹配，则返回true。 |
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 })
/*
------ any -------
true
false
*/
println(" ------ all -------")
println(list1.all { it > 2 })
/*
------ all -------
false
*/
println(" ------ none -------")
println(list1.none())
println(list1.none { it > 2 })
/*
------ none -------
false
false
*/
println(" ------ max -------")
println(list1.max())
println(list1.maxBy { it + 2 })
/*
------ max -------
5
5
*/
println(" ------ min -------")
println(list1.min()) // 返回集合中最小的元素
println(list1.minBy { it + 2 })
/*
------ min -------
1
1
*/
println(" ------ sum -------")
println(list1.sum())
println(list1.sumBy { it + 2 })
println(list1.sumByDouble { it.toDouble() })
/*
------ sum -------
15
25
15.0
*/
println(" ------ average -----")
println(list1.average())
/*
------ average -----
3.0
*/
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
})
/*
------ reduce -------
15
25
15
21
*/
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
})
/*
------ fold -------
18
28
18
28
*/
2、过滤操作符
| 操作符 | 作用 |
|---|---|
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())
/*
------ filter -------
[3, 5, 6, 7, 2, 4, 10, 9, 8]
[5]
[-1, -3, 1]
[1, 3, 4, 5, 6, 10]
*/
println(" ------ take -------")
println(list1.take(5))
println(list1.takeWhile { it < 5 })
println(list1.takeLast(5))
println(list1.takeLastWhile { it > 5 })
/*
------ take -------
[-1, -3, 1, 3, 5]
[-1, -3, 1, 3]
[2, 4, 10, 9, 8]
[10, 9, 8]
*/
println(" ------ drop -------")
println(list1.drop(5))
println(list1.dropWhile { it < 5 })
println(list1.dropLast(5))
println(list1.dropLastWhile { it > 5 })
/*
------ drop -------
[6, 7, 2, 4, 10, 9, 8]
[5, 6, 7, 2, 4, 10, 9, 8]
[-1, -3, 1, 3, 5, 6, 7]
[-1, -3, 1, 3, 5, 6, 7, 2, 4]
*/
println(" ------ distinct -------")
println(list3.distinct())
println(list3.distinctBy { it + 2 })
/*
------ distinct -------
[1, 5, 2, 6, 3, 7, 4, 8]
[1, 5, 2, 6, 3, 7, 4, 8]
*/
println(" ------ slice -------")
println(list1.slice(listOf(1,3,5,7)))
println(list1.slice(IntRange(1,5)))
/*
------ slice -------
[-3, 3, 6, 2]
[-3, 1, 3, 5, 6]
*/
3、映射操作符
| 操作符 | 作用 |
|---|---|
map{...} | 把每个元素按照特定的方法进行转换，组成一个新的集合。 |
mapNotNull{...} | 同map{}函数的作用相同，只是过滤掉转换之后为null的元素 |
mapIndexed{index,result} | 把每个元素按照特定的方法进行转换，只是其可以操作元素的下标(index)，组成一个新的集合。 |
mapIndexedNotNull{index,result} | 同mapIndexed{}函数的作用相同，只是过滤掉转换之后为null的元素 |
flatMap{...} | 根据条件合并两个集合，组成一个新的集合。 |
groupBy{...} | 分组。即根据条件把集合拆分为为一个Map<K,List>类型的集合。具体看实例 |
示例：
val list1 = listOf("kotlin","Android","Java","PHP","JavaScript")
println(" ------ map -------")
println(list1.map { "str-".plus(it) })
/*
------ map -------
[str-kotlin, str-Android, str-Java, str-PHP, str-JavaScript]
*/
println(" ------ mapNotNull -------")
println(list1.mapNotNull { "str-".plus(it) })
/*
------ mapNotNull -------
[str-kotlin, str-Android, str-Java, str-PHP, str-JavaScript]
*/
println(" ------ mapIndexed -------")
println(list1.mapIndexed { index, str ->
index.toString().plus("-").plus(str)
})
/*
------ mapIndexed -------
[0-kotlin, 1-Android, 2-Java, 3-PHP, 4-JavaScript]
*/
println(" ------ mapIndexedNotNull -------")
println(list1.mapIndexedNotNull { index, str ->
index.toString().plus("-").plus(str)
})
/*
------ mapIndexedNotNull -------
[0-kotlin, 1-Android, 2-Java, 3-PHP, 4-JavaScript]
*/
println(" ------ flatMap -------")
println( list1.flatMap { listOf(it,"new-".plus(it)) })
/*
------ flatMap -------
[kotlin, new-kotlin, Android, new-Android, Java, new-Java, PHP, new-PHP, JavaScript, new-JavaScript]
*/
println(" ------ groupBy -------")
println(list1.groupBy { if (it.startsWith("Java")) "big" else "latter" })
/*
------ groupBy -------
{latter=[kotlin, Android, PHP], big=[Java, JavaScript]}
*/
4、顺序操作符
| 操作符 | 作用 |
|---|---|
reversed() | 反序。即和初始化的顺序反过来。 |
sorted() | 自然升序。 |
sortedBy{...} | 根据条件升序，即把不满足条件的放在前面，满足条件的放在后面 |
sortedDescending() | 自然降序。 |
sortedByDescending{...} | 根据条件降序。和sortedBy{}相反 |
示例：
val list1 = listOf(-1, -3, 1, 3, 5, 6, 7, 2, 4, 10, 9, 8)
// 反序
println(list1.reversed())
//[8, 9, 10, 4, 2, 7, 6, 5, 3, 1, -3, -1]
// 升序
println(list1.sorted())
//[-3, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// 根据条件升序，即把不满足条件的放在前面，满足条件的放在后面
println(list1.sortedBy { it % 2 == 0 })
//[-1, -3, 1, 3, 5, 7, 9, 6, 2, 4, 10, 8]
// 降序
println(list1.sortedDescending())
//[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, -1, -3]
// 根据条件降序，和`sortedBy{}`相反
println(list1.sortedByDescending { it % 2 == 0 })
//[6, 2, 4, 10, 8, -1, -3, 1, 3, 5, 7, 9]
5、生产操作符
| 操作符 | 作用 |
|---|---|
plus() | 合并两个集合中的元素，组成一个新的集合。也可以使用符号+ |
zip | 由两个集合按照相同的下标组成一个新集合。该新集合的类型是：List |
unzip | 和zip的作用相反。把一个类型为List的集合拆分为两个集合。看下面的例子 |
partition | 判断元素是否满足条件把集合拆分为有两个Pair组成的新集合。 |
示例：
val list1 = listOf(1,2,3,4)
val list2 = listOf("kotlin","Android","Java","PHP","JavaScript")
// plus() 和 `+`一样
println(list1.plus(list2))
println(list1 + list2)
//[1, 2, 3, 4, kotlin, Android, Java, PHP, JavaScript]
//[1, 2, 3, 4, kotlin, Android, Java, PHP, JavaScript]
// zip
println(list1.zip(list2))
println(list1.zip(list2){ // 组成的新集合由元素少的原集合决定
it1,it2-> it1.toString().plus("-").plus(it2)
})
//[(1, kotlin), (2, Android), (3, Java), (4, PHP)]
//[1-kotlin, 2-Android, 3-Java, 4-PHP]
// unzip
val newList = listOf(Pair(1,"Kotlin"),Pair(2,"Android"),Pair(3,"Java"),Pair(4,"PHP"))
println(newList.unzip())
//([1, 2, 3, 4], [Kotlin, Android, Java, PHP])
// partition
println(list2.partition { it.startsWith("Ja") })
//([Java, JavaScript], [kotlin, Android, PHP])
6、元素操作符
| 操作符 | 作用 |
|---|---|
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()相反 |
last{} | 同first{}相反 |
lastOrNull{} | 同firstOrNull()相反 |
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只能代表1…5。详情可看下面的例子 |
示例：
val list = listOf("kotlin","Android","Java","PHP","Python","IOS")
println(" ------ contains -------")
println(list.contains("JS"))
/*
------ contains -------
false
*/
println(" ------ elementAt -------")
println(list.elementAt(2))
println(list.elementAtOrElse(10,{it}))
println(list.elementAtOrNull(10))
/*
------ elementAt -------
Java
10
null
*/
println(" ------ get -------")
println(list.get(2))
println(list.getOrElse(10,{it}))
println(list.getOrNull(10))
/*
------ get -------
Java
10
null
*/
println(" ------ first -------")
println(list.first())
println(list.first{ it == "Android" })
println(list.firstOrNull())
println(list.firstOrNull { it == "Android" })
/*
------ first -------
kotlin
Android
kotlin
Android
*/
println(" ------ last -------")
println(list.last())
println(list.last{ it == "Android" })
println(list.lastOrNull())
println(list.lastOrNull { it == "Android" })
/*
------ last -------
IOS
Android
IOS
Android
*/
println(" ------ indexOf -------")
println(list.indexOf("Android"))
println(list.indexOfFirst { it == "Android" })
println(list.indexOfLast { it == "Android" })
/*
------ indexOf -------
1
1
1
*/
println(" ------ single -------")
val list2 = listOf("list")
println(list2.single()) // 只有当集合只有一个元素时，才去用这个函数，不然都会抛出异常。
println(list2.single { it == "list" }) //当集合中的元素满足条件时，才去用这个函数，不然都会抛出异常。若满足条件返回该元素
println(list2.singleOrNull()) // 只有当集合只有一个元素时，才去用这个函数，不然都会返回null。
println(list2.singleOrNull { it == "list" }) //当集合中的元素满足条件时，才去用这个函数，不然返回null。若满足条件返回该元素
/*
------ single -------
list
list
list
list
*/
println(" ------ forEach -------")
list.forEach { println(it) }
list.forEachIndexed { index, it -> println("index : $index \t value = $it") }
/*
------ forEach -------
kotlin
Android
Java
PHP
Python
IOS
index : 0 value = kotlin
index : 1 value = Android
index : 2 value = Java
index : 3 value = PHP
index : 4 value = Python
index : 5 value = IOS
*/
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)`
/*
------ componentX -------
kotlin
Android
Java
PHP
Python
*/
版权声明：本文为weixin_42046829原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。