Java 中已经提供了很强大的集合框架，提供了常用的集合类型，比如 List、Set、Map 等。而 Kotlin 同样提供了一些集合，相比 Java 而言相对简单操作起来更加流畅。本文介绍 Kotlin 中的常见集合类型和适用于集合的操作函数。
Kotlin 中集合 API 请点击这里：https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/index.html
下面是 Kotlin 中定义的一些常用的集合接口和类：
Iterable: 实现这个接口的类代表一个可以遍历的元素序列。
MutableIterable： 这个接口代表在遍历元素的时候可以从集合中删除元素
Collection： 继承 Iterable 接口。代表通用的只读集合。
MutableCollection： 继承 Collection 和 MutableIterable 接口。代表通用的可以添加和删除元素的集合。
List： 继承 Collection 接口，代表有序的只读元素集合，可以使用元素索引来访问元素。
MutableList： 继承 List 和 MutableCollection 代表可以添加和删除元素的 List。
Set： 继承 Collection 接口，代表无序的只读元素集合，不能保护重复的元素。
MutableSet： 继承 Set 和 MutableCollection 代表可以添加和删除元素的 Set。
- Map： 代表只读的键值对元素集合。
MutableMap： 继承 Map,代表可以往里面添加和删除元素的 Map。
从上面的定义可以看出 Kotlin 中的集合和 Java 中类似，只不过区分了只读集合和可读写集合。
另外 Kotlin 中创建集合通常使用工厂函数，而不是构造函数：
val items = listOf(1, 2, 3, 4) val rwList = mutableListOf(1, 2, 3)
除此之外，Kotlin 中操作集合的各种扩展函数才是最强大的。
下面的代码示例中会使用大量 Lambda 表达式，这样代码看起来才更简洁，并且 Kotlin 中直接支持 Lambda 表达式和高阶函数，所以使用起来更加简洁。如果你不了解 Lambda 表达式，请参考掌握 Java 8 Lambda 表达式 blog.chengyunfeng.com/?p=902 和 Kotlin Lambda。
集合扩展函数
下面代码中使用的集合为
val list = listOf(1, 2, 3, 4, 5, 6)
any
如果有任何元素满足条件就返回 true.
assertTrue(list.any { it % 2 == 0 })assertFalse(list.any { it > 10 })
all
只有当所有元素都满足条件的时候才返回 true。
assertTrue(list.all { it < 10 })assertFalse(list.all { it % 2 == 0 })
count
计算满足条件的元素个数
assertEquals(3, list.count { it % 2 == 0 })
fold
计算集合累积值。
assertEquals(25, list.fold(4) { total, next -> total + next })
fold 函数有两个参数：initial 和 operation。
其中 initial 为初始值，operation 为一个高阶函数，这个函数有两个参数 R 和 T 并返回 R。
flod 函数会在所有集合元素上调用 operation 函数，在第一次调用的时候， R 值为 initial， T 为第一个集合元素，返回值作为下次调用 operation 的 R 参数，而 下一个集合元素为下一次 operation 调用的 T 参数，依次来遍历集合。
所以上面示例代码中实现的功能是，使用初始值 4 来计算 lsit 集合中所有元素加上 4 的和。
foldRight
和 fold 类似，只不过是从集合中最后一个元素开始。
assertEquals(25, list.foldRight(4) { total, next -> total + next })
forEach 和 forEachIndexed
在每个集合元素上执行一个操作。
list.forEach { println(it) } list.forEachIndexed { index, value -> println("position $index contains a $value") }
max
返回集合中最大的元素。如果没有元素则返回 null
assertEquals(6, list.max())
maxBy
使用函数参数计算的值作为比较对象。返回最大的元素中的值。
// 比较的是元素的负数，所以最大值为 1assertEquals(1, list.maxBy { -it })
min 和 minBy
和上面的 max 类似。
assertEquals(1, list.min())assertEquals(6, list.minBy { -it })
none
如果没有元素满足条件则返回 true。
assertTrue(list.none { it % 7 == 0 })
reduce 和 reduceRight
没有初始值的 fold。
assertEquals(21, list.reduce { total, next -> total + next })assertEquals(21, list.reduceRight { total, next -> total + next })
sumBy
在每个集合元素上应用一个函数，返回所有这个函数返回的结果相加一起的值。
assertEquals(3, list.sumBy { it % 2 })
在每个集合元素上应用 it % 2，所以结果分别为 1、0、1、0、1、0，然后把这些值相加，结果为 3.
drop
返回一个新的集合，里面不包含前 N 个元素。
assertEquals(listOf(5, 6), list.drop(4))
也就是 丢掉 N 个元素
dropWhile
返回新的集合，集合元素从第一个不满足条件的元素开始。
assertEquals(listOf(3, 4, 5, 6), list.dropWhile { it < 3 })
dropLastWhile
返回新的集合，里面的元素只包含第一个满足条件的元素之前的元素。
assertEquals(listOf(1, 2, 3, 4), list.dropLastWhile { it > 4 })
当元素 大于 4 的时候丢弃后面的所有元素，也就是遇到满足条件的元素则停止，返回前面的元素为新的集合。
filter
返回满足条件的元素为新的集合。
assertEquals(listOf(2, 4, 6), list.filter { it % 2 == 0 })
filterNot
返回不满足条件的元素
assertEquals(listOf(1, 3, 5), list.filterNot { it % 2 == 0 })
filterNotNull
返回所有不是 null 的元素为新的集合
var listWithNull = listOf(1, 2, 3, null, 4)assertEquals(listOf(1, 2, 3, 4), listWithNull.filterNotNull())
slice
返回特定位置的元素为新的集合
assertEquals(listOf(2, 4, 5), list.slice(listOf(1, 3, 4)))
take
取前 N 个元素
assertEquals(listOf(1, 2), list.take(2))
takeLast
取后 N 个元素
assertEquals(listOf(5, 6), list.takeLast(2))
takeWhile
取前面所有满足条件的元素
assertEquals(listOf(1, 2), list.takeWhile { it < 3 })
flatMap
flatMap 的参数为 transform: (T) -> Iterable<R>， 意味着是一个需要参数 T 并返回集合 T 的函数。也就是说，使用集合中的每个元素去调用 transform 函数，每次调用会得到一个新的集合，然后把这些集合中的元素拿出来生成一个新的集合，这个集合为 flatMap 的返回值。
assertEquals(listOf(1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7), list.flatMap { listOf(it, it + 1) })
groupBy
groupBy 的参数为 keySelector: (T) -> K。使用集合中的每个元素调用 keySelector 函数返回一个对象为 Key。把所有key一样的元素放到一个集合中，然后把 key 作为 键、对应的元素组成的集合作为 值 放到 map 中，然后 groupBy 返回这个 map 对象。
assertEquals(mapOf("odd" to listOf(1, 3, 5), "even" to listOf(2, 4, 6)), list.groupBy { if (it % 2 == 0) "even" else "odd" })
map
在集合中每个元素应用一个操作，返回的值组成新的集合
assertEquals(listOf(2, 4, 6, 8, 10, 12), list.map { it * 2 })
mapIndexed
和 map 类似，只不过参数中包含了元素的 index。
assertEquals(listOf (0, 2, 6, 12, 20, 30), list.mapIndexed { index, it -> index * it })
mapNotNull
和 map 类似，只不过返回的集合中不包含 null 值。
assertEquals(listOf(2, 4, 6, 8), listWithNull mapNotNull { it * 2 })
contains
如果集合包含特定的元素则返回 true
assertTrue(list.contains(2))
elementAt
返回特定位置的元素
assertEquals(2, list.elementAt(1))
elementAtOrElse
返回特定位置的元素，如果没有则返回一个其他的值。
assertEquals(20, list.elementAtOrElse(10, { 2 * it }))
elementAtOrNull
返回特定位置的值，如果没有则返回 null
assertNull(list.elementAtOrNull(10))
first 和 firstOrNull
返回第一个满足条件的值或者 null
assertEquals(2, list.first { it % 2 == 0 })assertNull(list.firstOrNull { it % 7 == 0 })
indexOf
返回元素在集合中的位置
assertEquals(3, list.indexOf(4))
indexOfFirst 和 indexOfLast
返回集合中满足特定条件的第一个/最后一个元素的位置
assertEquals(1, list.indexOfFirst { it % 2 == 0 })assertEquals(5, list.indexOfLast { it % 2 == 0 })
last
返回最后一个满足条件的元素
assertEquals(6, list.last { it % 2 == 0 })
lastIndexOf
返回特定元素的最后一个位置
val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)assertEquals(5, listRepeated.lastIndexOf(5))
lastOrNull
返回满足条件的最后一个元素，如果没有返回 null
val list = listOf(1, 2, 3, 4, 5, 6)assertNull(list.lastOrNull { it % 7 == 0 })
single
如果只有一个元素满足特定条件，则返回这个元素，如果有多个元素满足则抛出异常
assertEquals(5, list.single { it % 5 == 0 })
singleOrNull
如果只有一个元素满足特定条件，则返回这个元素,否则返回 null
assertNull(list.singleOrNull { it % 7 == 0 })
merge
分别使用两个集合中的元素调用一个函数，把结果放到新的集合中返回。如果两个集合长度不一样，则返回的集合长度为最短的集合长度
val list = listOf(1, 2, 3, 4, 5, 6)val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)assertEquals(listOf(3, 4, 6, 8, 10, 11), list.merge(listRepeated) { it1, it2 -> it1 + it2 })
partition
把一个集合中的元素安装条件分为两个集合，满足条件的为一个集合，不满足条件的为另外一个集合。
assertEquals(Pair(listOf(2, 4, 6), listOf(1, 3, 5)), list.partition { it % 2 == 0 })
plus
两个集合相加并返回。
assertEquals(listOf(1, 2, 3, 4, 5, 6, 7, 8), list + listOf(7, 8))
zip 和 unzip
这个是把两个集合中同样位置的元素放到 Pair 中，并把所有的 Pair 对象放到新的 List 中返回。返回 List 的长度为两个 list 中元素个数最小值。 unzip 实现相反的功能。
assertEquals(listOf(Pair(1, 7), Pair(2, 8)), list.zip(listOf(7, 8)))
reverse
按照逆序的方式返回新的集合
val unsortedList = listOf(3, 2, 7, 5)assertEquals(listOf(5, 7, 2, 3), unsortedList.reverse())
sort
集合元素排序
assertEquals(listOf(2, 3, 5, 7), unsortedList.sort())
sortBy
集合元素按照指定的排序方法来排序。
assertEquals(listOf(3, 7, 2, 5), unsortedList.sortBy { it % 3 })
sortDescending 和 sortDescendingBy
集合元素降序来排序
assertEquals(listOf(7, 5, 3, 2), unsortedList.sortDescending())assertEquals(listOf(2, 5, 7, 3), unsortedList.sortDescendingBy { it % 3 })
more…
文章转载: https://blog.csdn.net/qq_31265199/article/details/75497920
