集合和函數操做符 for kotlin

雖然咱們能夠直接用Java中的集合，可是Kotlin也提供了一些你但願用的本地的接
口：
Iterable：父類。全部咱們能夠遍歷一系列的都是實現這個接口。
MutableIterable：一個支持遍歷的同時能夠執行刪除的Iterables。
Collection：這個類相是一個範性集合。咱們經過函數訪問能夠返回集合的size、是否爲空、是否包含一個或者一些item。這個集合的全部方法提供查詢，由於connections是不可修改的。
MutableCollection：一個支持增長和刪除item的Collection。它提供了額外的函數，好比 add  、 remove  、 clear  等等。
List：多是最流行的集合類型。它是一個範性有序的集合。由於它的有序，咱們可使用 get  函數經過position來訪問。
MutableList：一個支持增長和刪除item的List。
Set：一個無序並不支持重複item的集合。
MutableSet：一個支持增長和刪除item的Set。
Map：一個key-value對的collection。key在map中是惟一的，也就是說不能有兩對key是同樣的鍵值對存在於一個map中。
MutableMap：一個支持增長和刪除item的map。
有不少不一樣集合可用的函數操做符。我想經過一個例子來展現給你看。知道有哪些
可選的操做符是頗有用的，由於這樣會更容易分辨它們使用的時機。

總數操做符
any
若是至少有一個元素符合給出的判斷條件，則返回true。
val list = listOf(1, 2, 3, 4, 5, 6)
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。
// The element whose negative is greater
assertEquals(1, list.maxBy { -it })

min
返回最小的一項，若是沒有則返回null。
assertEquals(1, list.min())

minBy
根據給定的函數返回最小的一項，若是沒有則返回null。
// The element whose negative is smaller
assertEquals(6, list.minBy { -it })

none
若是沒有任何元素與給定的函數匹配，則返回true。
// No elements are divisible by 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 .ilter { 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 { ind
ex, 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 })