kotliln基础

1 集合 API 汇总

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唯一。

MutableMap：继承Map。支持put/remove元素

2 集合操作符（字母顺序排序）

any

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

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

all

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

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

associate

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

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

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

average

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

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

component1,…,component5

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

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

contain

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

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

containsAll

如果指定集合所有元素都可以在目标集合找到，则 返回true

val list = listOf(4,1,2,3,4)
val subList = listOf(2,1)
assertTrue(list.containsAll(subList))

count

返回与判断条件相符的元素个数

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

distinct

返回一个只包含不同元素的数组

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

distinctBy

返回集合元素执行指定条件后，不同元素的数组（原始数组元素）

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

drop

返回所有元素的列表，但不包含前n个元素

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

dropLast

返回所有元素的列表，但不包含最后n个元素

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

dropWhile

返回所有元素的列表，但不包含满足判断条件的元素

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

dropLastWhile

返回所有元素的列表，但不包含从列表最后开始满足条件的元素

//2不满足
val list = listOf(1,2,3,4,2)
assertEquals(listOf(1,2,3,4,2),list.dropLastWhile{it >3})
//4,5满足
val list = listOf(1,2,3,4,5)
assertEquals(listOf(1,2,3),list.dropLastWhile{it >3})

elementAt

返回指定索引的元素，如果索引越界，则抛出ArrayIndexOutOfBoundsException

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

elementAtOrElse

返回指定索引的元素，如果索引越界，则返回指定的默认值

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

elementAtOrElse

返回指定索引的元素，如果索引越界，则返回null

val list = listOf(1,2,3,4)
assertEquals(null,list.elementAtOrNull(6))

filter

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

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

filterIndexed

筛选出所有符合条件的元素（条件多了一个索引参数）

val list = listOf(1, 4, 2, 2)
assertEquals(listOf(4),list.filterIndexed { index, it ->  index>0 && it >2} )

filterNot

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

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

filterNotNull

筛选出所有不为null的元素

val list = listOf(1,2,3,null,4)
assertEquals(listOf(1,2,3,4),list.filterNotNull())

first

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

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

firstOrNull

返回第一个满足条件的元素，没有，则 返回Null

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

find

同firstOrNull。返回第一个满足条件的元素，没有，则 返回Null

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

findLast

返回最后一个满足条件的元素，没有，则 返回Null

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

flatMap

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

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

flatten

遍历一个单独的集合，包含给定嵌套集合里面的所有元素。

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

fold

将对集合从第一个到最后一个元素进行操作

//这里是进行乘法操作
val list = listOf(1, 2, 3, 4)
assertEquals(48, list.fold(2) { total, next -> total * next })

foldRight

跟fold操作一样，不过是从最后一个到到一个元素进行操作

//这里是进行乘法操作
val list = listOf(1, 2, 3, 4)
assertEquals(48, list.foldRight(2) { total, next -> total * next })

get

获取索引所在的元素，没有则返回ArrayIndexOutOfBoundsException

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

getOrElse

获取索引所在的元素，没有就返回默认值

val list = listOf(1, 2, 4, 2, 3, 4)
assertEquals(10, list.getOrElse(8, { _ -> 10 }))
assertEquals(2, list.getOrElse(1, { _ -> 10 }))

getOrNull

获取索引所在的元素，没有就返回nul

val list = listOf(1, 2, 4, 2, 3, 4)
assertEquals(null, list.getOrNull(8))
assertEquals(4, list.getOrNull(2))

groupBy

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

val list = listOf(1, 2, 2, 4)
assertEquals(mapOf("error" to listOf(1), "right" to listOf(2, 2, 4)), list.groupBy { if (it % 2 == 0) "right" else "error" })

indexOf

返回指定元素的第一个索引位置，不存在返回-

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

indexOfFirst

返回第一个符合指定条件的元素索引，不存在返回-1

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

indexOfLast

返回符合指定条件的最后一个索引位置，不存在返回-1

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

last

返回符合给定函数条件的最后一个元素，不存在则抛出NoSuchElementException

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

lastIndexOf

返回指定元素的第一个索引位置，不存在返回-1

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

lastOrNull

返回符合给定函数条件的最后一个元素，不存在返回null

val list = listOf(1, 2, 2, 4)
assertNull( list.lastOrNull{ it >5})

map

返回一个每个元素都根据给定函数条件转换的数组

val list = listOf(1, 2, 2, 4)
assertEquals(listOf(2, 4, 4, 8), list.map{ it*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 })

mapNotNull

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

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

max

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

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

maxBy

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

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

min

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

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

minBy

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

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

none

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

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

orEmpty

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

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

partition

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

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

plus

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

val list = listOf(1, 2, 2, 4)
val listTwo = listOf(5, 6)
assertEquals(listOf(1, 2, 2, 4, 5, 6), porkbun.com | parked domain(listTwo))
assertEquals(listOf(1, 2, 2, 4, 5, 6), list + listTwo)

reduce

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

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

reduceRight

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

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

reverse

倒序排列集合

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

single

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

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

singleOrNull

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

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

sorted

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

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

sortBy

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

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

sortDescending

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

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