Kotlin学习(五) 集合

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