Kotlin的集合操作符

Iterable：任何实现这个接口的，都可以遍历元素

MutableIterable：继承Iterable接口。并提供给我们移除的方法

Collection：元素的通用的范性集合，这个集合是一个只读的集合，它提供给我们可以获取集合的size，是否为空，是否包含某个或某组数据等方法。

MutableCollection：继承Collection,MutableIterable。并提供了额外的函数add,addAll,remove,clear等方法

List：继承Collection。一个范性有序的只读集合。因为有序，所以，我们可以使用get(position)等查询的方法

MutableList：继承List，MutableCollection。一个有序集合。并额外提供了add/remove元素的方法

Set：继承Collection。一个无序并不支持重复元素的集合

MutableSet：继承Set，MutableCollection，一个无序的集合并且不支持重复元素。但是，支持add/remove元素

Map：一个key-value的只读集合。并且key唯一。

any

如果至少有一个元素与判断条件相符，则 返回true

val list = listOf(1,2,3)
assertTrue { list.any{it >2} }
1
2

all

如果全部元素与判断条件相符，则 返回true

val list = listOf(1,2,3)
assertTrue { list.all{it < 4} }
1
2

associate

通过指定的条件，把list转换成map

val list = listOf(1, 2)
assertEquals(mutableMapOf(Pair("a1",1),Pair("a2",2)), list.associate({ it -> Pair("a"+it,it)}))
1
2

associateBy

通过指定的条件，把list转换成map。2种，第一只转换map的key;第二map的key-value都转换

val list = listOf(1, 4, 2, 2)
assertEquals(hashMapOf("key1" to 1, "key4" to 4, "key2" to 2), list.associateBy { it -> "key" + it })
assertEquals(hashMapOf("key1" to "value1", "key4" to "value4", "key2" to "value2"), list.associateBy({ it -> "key" + it }, { it -> "value" + it }))
1
2
3

average

求集合的平均值(元素之和/元素大小)。仅限（Byte，Short，Int，Long，Float,Double）

val list = listOf(1, 4, 2, 2)
assertEquals(2.25,list.average())
1
2

component1,…,component5

返回集合的第n个元素，越界返回ArrayIndexOutOfBoundsException

val list = listOf(1, 4, 2, 2)
assertEquals(1,list.component1())
assertEquals(4,list.component2())
1
2
3

filter

筛选出所有符合条件的元素

val list = listOf(1,2,3,4)
assertEquals(listOf(2,3),list.filter{ it in 2..3 })
1
2

first

返回第一个满足条件的元素,没有则抛出NoSuchElementException

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

mapIndexed

功能同map，比map多了一个索引

val list = listOf(1, 2, 2, 4)
assertEquals(listOf(0, 2, 4, 4), list.mapIndexed { index, it -> if (index % 2 == 0) index * it else it })
1
2

mapNotNull

同map。但是，元素转换不包含Null

val list = listOf(1, 2,null, 2, 4)
assertEquals(listOf(2, 4, 4, 8), list.mapNotNull { it?.times(2) })
1
2

max

返回集合最大元素。不存在返回null

val list = listOf(1, 2, 2, 4)
assertEquals(4, list.max())
val list = emptyList<Int>()
assertEquals(null, list.max())
1
2
3
4

maxBy

返回根据指定函数转换后，产生的最大值的原始元素（返回的还是原始元素）。如果没有元素，则返回null。

val list = listOf(1, 2, 2, 4)
assertEquals(1, list.maxBy { -it })
1
2

min

返回集合最小元素，不存在返回null

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

minBy

返回根据指定函数转换后，产生的最小值的原始元素（返回的还是原始元素）。如果没有元素，则返回null。

val list = listOf(1, 2, 2, 4)
assertEquals(4, list.minBy { -it })
1
2

none

如果没有任何元素与指定的函数条件匹配，则返回true。

val list = mutableListOf(1, 2, 2, 4)
assertTrue(list.none { it > 4 })
1
2

orEmpty

如果没有任何元素与指定的函数条件匹配，则返回true。

val list = mutableListOf(1, 2, 2, 4)
assertTrue(list.none { it > 4 })
1
2

partition

把一个指定的集合分割成2个。第一个集合是所有符合指定函数条件的，第二个集合是所有不符合指定条件的集合

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

plus

返回一个包含原集合和给定集合中所有元素的集合。也可以使用+操作符

val list = listOf(1, 2, 2, 4)
val listTwo = listOf(5, 6)
assertEquals(listOf(1, 2, 2, 4, 5, 6), list.plus(listTwo))
assertEquals(listOf(1, 2, 2, 4, 5, 6), list + listTwo)
1
2
3
4

reduce

与fold功能一样。但是，没有初始值。把集合从第一个到最后一个，按指定条件进行操作

val list = listOf(1, 2, 2, 4)
assertEquals(-7, list.reduce { total, next -> total -next })
1
2

reduceRight

与reduce一样。但是，顺序是从最后一个到第一个，按指定条件操作

val list = listOf(1, 2, 2, 4)
assertEquals(-1, list.reduceRight { next, total -> total - next })
1
2

reverse

倒序排列集合

val list = listOf(1, 2, 2, 4)
assertEquals(listOf(4,2,2,1), list.reversed())
1
2

single

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

val list = listOf(1, 2, 2, 4)
assertEquals(4, list.single { it == 4 })
1
2

singleOrNull

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

val list = listOf(1, 2, 2, 4)
assertEquals(null, list.singleOrNull { it == 2 })
1
2

sorted

返回所有元素分类排序列表。

val list = listOf(1, 4, 2, 2)
assertEquals(listOf(1, 2, 2, 4), list.sorted())
1
2

sortBy

返回所有元素分类排序列表。顺序按照指定函数条件排列

val list = listOf(1, 4, 2, 2)
assertEquals(listOf(4,2,2,1), list.sortedBy { -it })
1
2

sortDescending
1

返回所有元素分类排序列表。顺序按降序排列

val list = listOf(1, 4, 2, 2)
assertEquals(listOf(4,2,2,1), list.sortedDescending())
1
2

sortedByDescending

返回所有元素分类排序列表。顺序按指定函数条件的降序排列

val list = listOf(1, 4, 2, 2)
assertEquals(listOf(1,2,2,4), list.sortedByDescending{ -it })
1
2

sum

返回集合中元素值的总和。

val list = listOf(1, 4, 2, 2)
assertEquals(9, list.sum())
1
2

sumBy

返回集合中元素按照指定函数条件转换后产生值的总和。

val list = listOf(1, 4, 2, 2)
assertEquals(-9, list.sumBy{ -it })
1
2

slice

返回一个list中指定index的元素。

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

take

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

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

takeLast

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

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

takeWhile

返回从最后一个元素开始符合指定函数条 件的元素。（碰到不符合条件的，不往下走）

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

zip

返回一个列表，该列表由两个集合中相同索引元素建立的元素对。这个列表长度为最短集合的长度。

val list = listOf(1, 4, 2, 2)
assertEquals(listOf(Pair(1,10),Pair(4,20),Pair(2,30)), list.zip(listOf(10,20,30)))
1
2