kotlin list集合操做

总数操做符

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 })
复制代码