Kotlin学习笔记——标准库kotlin.collections

最新推荐文章于 2023-11-27 21:52:43 发布

hjkcghjmguyy

最新推荐文章于 2023-11-27 21:52:43 发布

阅读量1.6k

点赞数

分类专栏： Android 文章标签： kotlin

本文链接：https://blog.csdn.net/hjkcghjmguyy/article/details/73879795

版权

Android 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

总数操作符

any()

如果至少有一个元素，或者至少有一个元素符合给出的判断条件，则返回true。

val list = listOf(1, 2, 3, 4, 5, 6)
assertTrue(list.any())
assertTrue(list.any { it % 2 == 0 })
assertFalse(list.any { it > 10 })

all()

如果全部的元素符合给出的判断条件，则返回true。

val list = listOf(1, 2, 3, 4, 5, 6)
assertTrue(list.all { it < 10 })
assertFalse(list.all { it % 2 == 0 })

count()

返回包含的元素个数，或者符合给出判断条件的元素个数。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(6, list.count())
assertEquals(3, list.count { it % 2 == 0 })

forEach()

遍历所有元素，并执行给定的操作。

val list = listOf(1, 2, 3, 4, 5, 6)
list.forEach { println(it) }

forEachIndexed()

与 forEach ，但是我们同时可以得到元素的index。

val list = listOf(1, 2, 3, 4, 5, 6)
list.forEachIndexed { index, value-> println("position $index contains a $value") }

max()

返回最大的一项，如果没有则返回null。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(6, list.max())

maxBy()

根据给定的函数返回最大的一项，如果没有则返回null。

val list = listOf(1, 2, 3, 4, 5, 6)
// The element whose negative is greater
assertEquals(1, list.maxBy { -it })

min()

返回最小的一项，如果没有则返回null。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(1, list.min())

minBy()

根据给定的函数返回最小的一项，如果没有则返回null。

val list = listOf(1, 2, 3, 4, 5, 6)
// The element whose negative is smaller
assertEquals(6, list.minBy { -it })

none()

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

val list = listOf(1, 2, 3, 4, 5, 6)
assertFalse(list.none())
// No elements are divisible by 7
assertTrue(list.none { it % 7 == 0 })

fold()

在一个初始值的基础上从第一项到最后一项通过一个函数累计所有的元素。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(25, list.fold(4) { total, next -> total + next })

foldRight()

与 fold 一样，但是顺序是从最后一项到第一项。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(25, list.foldRight(4) { total, next -> total + next})

reduce()

与 fold 一样，但是没有一个初始值。通过一个函数从第一项到最后一项进行累计。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(21, list.reduce { total, next -> total + next })

reduceRight()

与 reduce 一样，但是顺序是从最后一项到第一项。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(21, list.reduceRight { total, next -> total + next})

sumBy()

返回所有每一项通过函数转换之后的数据的总和。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(3, list.sumBy { it % 2 })

过滤操作符

drop()

返回包含去掉前n个元素的所有元素的列表。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(5, 6), list.drop(4))

dropLast()

返回包含去掉最后n个元素的所有元素的列表。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(1, 2), list.dropLast(4))

dropWhile()

返回根据给定函数从第一项开始去掉指定元素的列表。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(3, 4, 5, 6), list.dropWhile { it < 3 })

dropLastWhile()

返回根据给定函数从最后一项开始去掉指定元素的列表。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(1, 2, 3, 4), list.dropLastWhile { it > 4 })

filter()

过滤所有符合给定函数条件的元素。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(2, 4, 6), list .ilter { it % 2 == 0 })

filterNot()

过滤所有不符合给定函数条件的元素。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(1, 3, 5), list.filterNot { it % 2 == 0 })

filterNotNull()

过滤所有元素中不是null的元素。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(1, 2, 3, 4), listWithNull.filterNotNull())

filterTo()

过滤所有符合给定函数条件的元素，并赋值给目标

val list = listOf(1, 2, 3, 4, 5, 6)
val dest = mutableListOf<Int>()
assertEquals(listOf(4, 5, 6, 7), list.filterTo(dest, { it > 3 }))

slice()

过滤一个list中指定index的元素。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(2, 4, 5), list.slice(listOf(1, 3, 4)))

take()

返回从第一个开始的n个元素。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(1, 2), list.take(2))

takeLast()

返回从最后一个开始的n个元素。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(5, 6), list.takeLast(2))

takeWhile()

返回从第一个开始符合给定函数条件的元素。遇到不满足的元素，直接终止循环，并返回子集合。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(1, 2), list.takeWhile { it < 3 })

takeLastWhile()

返回从最后一个开始符合给定函数条件的元素。遇到不满足的元素，直接终止循环，并返回子集合。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf<Int>(), list.takeLastWhile { it < 3 })

分组操作符

groupBy()

返回一个根据给定函数分组后的map。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(mapOf("odd" to listOf(1, 3, 5), "even" to listOf(2,4, 6)), list.groupBy { if (it % 2 == 0) "even" else "odd" })

返回一个根据给定函数分组后的map。结果还可以根据第二个转换条件转换

val words = listOf("a", "abc", "ab", "def", "abcd")
println(words.groupBy({ it.length }))
println(words.groupBy({ it.length }, { it.contains("b") }))

val programmer = listOf("K&R" to "C", "Bjar" to "C++", "Linus" to "C", "James" to "Java")
println(programmer.groupBy({ it.second }))
println(programmer.groupBy({ it.second }, { it.first }))
println(programmer.groupBy({ it.second }, { it.second }))

结果：

{1=[a], 3=[abc, def], 2=[ab], 4=[abcd]}
{1=[false], 3=[true, false], 2=[true], 4=[true]}
{C=[(K&R, C), (Linus, C)], C++=[(Bjar, C++)], Java=[(James, Java)]}
{C=[K&R, Linus], C++=[Bjar], Java=[James]}
{C=[C, C], C++=[C++], Java=[Java]}

groupingBy()

按根据给定函数分组，结合eachCount()可以进行统计

val words = "one two three four five six seven eight nine ten".split(' ')
println(words.groupingBy({ it.first() }).eachCount())

结果：

{o=1, t=3, f=2, s=2, e=1, n=1}

映射操作符

map()

返回一个每一个元素根据给定的函数转换所组成的List。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(2, 4, 6, 8, 10, 12), list.map { it * 2 })

flatMap()

遍历所有的元素，为每一个创建一个集合，最后把所有的集合放在一个集合中。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf(1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7),list.flatMap { listOf(it, it + 1) })

mapIndexed()

返回一个每一个元素根据给定的包含元素index的函数转换所组成的List。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(listOf (0, 2, 6, 12, 20, 30), list.mapIndexed { index, it -> index * it })

mapNotNull()

返回一个每一个非null元素根据给定的函数转换所组成的List。

val listWithNull = listOf(1, 2, 3, 4, null, null)
assertEquals(listOf(2, 4, 6, 8), listWithNull.mapNotNull { it * 2})

元素操作符

contains()

如果指定元素可以在集合中找到，则返回true。

val list = listOf(1, 2, 3, 4, 5, 6)
assertTrue(list.contains(2))

elementAt()

返回给定index对应的元素，如果index数组越界则会抛出 IndexOutOfBoundsException 。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(2, list.elementAt(1))

elementAtOrElse()

返回给定index对应的元素，如果index数组越界则会根据给定函数返回默认值。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(20, list.elementAtOrElse(10, { 2 * it }))

elementAtOrNull()

返回给定index对应的元素，如果index数组越界则会返回null。

val list = listOf(1, 2, 3, 4, 5, 6)
assertNull(list.elementAtOrNull(10))

first()

返回符合给定函数条件的第一个元素。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(2, list.first { it % 2 == 0 })

firstOrNull()

返回符合给定函数条件的第一个元素，如果没有符合则返回null。

val list = listOf(1, 2, 3, 4, 5, 6)
assertNull(list.firstOrNull { it % 7 == 0 })

last()

返回符合给定函数条件的最后一个元素。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(6, list.last { it % 2 == 0 })

lastOrNull()

返回符合给定函数条件的最后一个元素，如果没有符合则返回null。

val list = listOf(1, 2, 3, 4, 5, 6)
assertNull(list.lastOrNull { it % 7 == 0 })

indexOf()

返回指定元素的第一个index，如果不存在，则返回 -1 。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(3, list.indexOf(4))

indexOfFirst()

返回第一个符合给定函数条件的元素的index，如果没有符合则返回 -1 。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(1, list.indexOfFirst { it % 2 == 0 })

indexOfLast()

返回最后一个符合给定函数条件的元素的index，如果没有符合则返回 -1 。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(5, list.indexOfLast { it % 2 == 0 })

lastIndexOf()

返回指定元素的最后一个index，如果不存在，则返回 -1 。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(-1, list.lastIndexOf(7))

single()

返回符合给定函数的单个元素，如果没有符合或者超过一个，则抛出异常。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(5, list.single { it % 5 == 0 })

singleOrNull()

返回符合给定函数的单个元素，如果没有符合或者超过一个，则返回null。

val list = listOf(1, 2, 3, 4, 5, 6)
assertNull(list.singleOrNull { it % 7 == 0 })

生产操作符

merge()

把两个集合合并成一个新的，相同index的元素通过给定的函数进行合并成新的元素作为新的集合的一个元素，返回这个新的集合。新的集合的大小由最小的那个集合大小决定。

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

把一个给定的集合分割成两个，第一个集合是由原集合每一项元素匹配给定函数条件返回 true 的元素组成，第二个集合是由原集合每一项元素匹配给定函数条件返回 false 的元素组成。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(
    Pair(listOf(2, 4, 6), listOf(1, 3, 5)),
    list.partition { it % 2 == 0 }
)

plus()

返回一个包含原集合和给定集合中所有元素的集合，因为函数的名字原因，我们可以使用 + 操作符。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(
    listOf(1, 2, 3, 4, 5, 6, 7, 8),
    list + listOf(7, 8)
)

zip()

返回由 pair 组成的List，每个 pair 由两个集合中相同index的元素组成。这个返回的List的大小由最小的那个集合决定。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(
    listOf(Pair(1, 7), Pair(2, 8)),
    list.zip(listOf(7, 8))
)

unzip()

从包含pair的List中生成包含List的Pair。

val list = listOf(1, 2, 3, 4, 5, 6)
assertEquals(
    Pair(listOf(5, 6), listOf(7, 8)),
    listOf(Pair(5, 7), Pair(6, 8)).unzip()
)

retainAll()

取两个集合交集。

val list = mutableListOf(1, 2, 3, 4, 5, 6)
val list2 = listOf(3, 4, 5, 6, 7, 8, 9)
assertEquals(listOf(3, 4, 5, 6), list.retainAll(list2))

顺序操作符

reverse()

返回一个与指定list相反顺序的list。

val unsortedList = listOf(3, 2, 7, 5)
assertEquals(listOf(5, 7, 2, 3), unsortedList.reverse())

sort()

返回一个自然排序后的list。

val unsortedList = listOf(3, 2, 7, 5)
assertEquals(listOf(2, 3, 5, 7), unsortedList.sort())

sortBy()

返回一个根据指定函数排序后的list。

val unsortedList = listOf(3, 2, 7, 5)
assertEquals(listOf(3, 7, 2, 5), unsortedList.sortBy { it % 3 })

sortDescending()

返回一个降序排序后的List。

val unsortedList = listOf(3, 2, 7, 5)
assertEquals(listOf(7, 5, 3, 2), unsortedList.sortDescending())

sortDescendingBy()

返回一个根据指定函数降序排序后的list。

val unsortedList = listOf(3, 2, 7, 5)
assertEquals(listOf(2, 5, 7, 3), unsortedList.sortDescendingBy {it % 3 })