kotlin list集合操作

1,251 阅读6分钟

总数操作符

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

foldRight

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

assertEquals(25, list.foldRight(4) { total, next -> total + next})

forEach

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

list.forEach { println(it) }

forEachIndexed

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

list.forEachIndexed { index, value-> println("position $index contains a $value") }

max

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

assertEquals(6, list.max())

maxBy

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

assertEquals(1, list.maxBy { -it })

min

返回最小的一项,如果没有则返回null。 assertEquals(1, list.min())

minBy

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

// 负数较小的元素
assertEquals(6, list.minBy { -it })

none

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

//没有元素可以被7整除
assertTrue(list.none { it % 7 == 0 })

reduce

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

assertEquals(21, list.reduce { total, next -> total + next })

reduceRight

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

assertEquals(21, list.reduceRight { total, next -> total + next})

sumBy

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

assertEquals(3, list.sumBy { it % 2 })

过滤操作符

drop

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

assertEquals(listOf(5, 6), list.drop(4))

dropWhile

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

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

dropLastWhile

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

assertEquals(listOf(1, 2, 3, 4), list.dropLastWhile { it > 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的元素。

assertEquals(listOf(1, 2, 3, 4), listWithNull.filterNotNull())

slice

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

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

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

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

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

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

assertEquals(listOf(2, 4, 6, 8, 10, 12), list.map { it * 2 })

mapIndexed

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

assertEquals(listOf (0, 2, 6, 12, 20, 30), list.mapIndexed { index, it -> index * it })

mapNotNull

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

assertEquals(listOf(2, 4, 6, 8), listWithNull.mapNotNull { it * 2})

元素操作符

contains

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

assertTrue(list.contains(2))

elementAt

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

assertEquals(2, list.elementAt(1))

elementAtOrElse

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

assertEquals(20, list.elementAtOrElse(10, { 2 * it }))

elementAtOrNull

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

assertNull(list.elementAtOrNull(10))

first

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

assertEquals(2, list.first { it % 2 == 0 })

firstOrNull

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

assertNull(list.firstOrNull { it % 7 == 0 })

indexOf

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

assertEquals(3, list.indexOf(4))

indexOfFirst

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

assertEquals(1, list.indexOfFirst { it % 2 == 0 })

indexOfLast

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

assertEquals(5, list.indexOfLast { it % 2 == 0 })

last

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

assertEquals(6, list.last { it % 2 == 0 })

lastIndexOf

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

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

把两个集合合并成一个新的,相同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 的元素组成。

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

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

assertEquals(listOf(Pair(1, 7), Pair(2, 8)), list.zip(listOf(7, 8)))

unzip

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

assertEquals(Pair(listOf(5, 6), listOf(7, 8)), listOf(Pair(5, 7), Pair(6, 8)).unzip())

顺序操作符

reverse

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

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

sort

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

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

sortBy

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

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

sortDescending

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

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

sortDescendingBy

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

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