Kotlin——集合详解

集合是开发中很是经常使用的知识，好比操做各类数据集，各类算法，保存网络请求结果，做为Adapter数据集，若是你不会集合的知识，那么可能连显示一个基本的ListView列表都作不到，今天就来讲说Kotlin中集合的知识。

Kotlin 中的集合按照可变性分类能够分为：

• 可变集合
• 不可变集合

按照类型分类能够分为：

• List集合
• Map集合
• Set集合

结合在一块儿就是说List，Map，Set又均可以分为可变和不可变两种。
具体来讲
对于List

• List ——声明不可变List集合
• MutableList——声明可变List集合

对于Map

• Map——声明不可变Map集合
• MutableMap——声明可变Map集合

对于Set

• Set——声明不可变Set集合
• MutableSet——声明可变Set集合

除此以外还有四个基本接口

• Iterable ——全部集合的父类
• MutableIterable —— 继承于Iterabl接口，支持遍历的同时能够执行删除操做
• Collection —— 继承于Iterable接口，仅封装了对集合的只读方法
• MutableCollection ——继承于Iterable,Collection，封装了添加或移除集合中元素的方法

此外，记住List ，MutableList，Set，MutableSet 归根到底都是Collection的子类。

集合的建立

Kotlin并无提供建立集合的函数，但咱们可使用以下方法来建立相应的集合

List

建立一个不可变的list

val mList = listOf (1, 2, 3)

建立一个可变的list

val mList = mutableListOf (1, 2, 3)

这里mutableListOf初始化了三个值，若是没有这三个值就至关于一个空集合，好比

val mList = mutableListOf<Int>()
    Log.i(TAG, "mList size:" + mList.size)
    mList.add(1)
    mList.add(2)
    Log.i(TAG, "mList size:" + mList.size)复制代码

打印结果为

com.kotlin.collection.example I/MainActivity: mList size:0
com.kotlin.collection.example I/MainActivity: mList size:2

这样就能够给须要初始值为空的列表进行赋值了，好比ListView的Adapter初始值为空的状况。
此外还有两个声明List集合的方法

• emptyList()——建立一个空集合
• listOfNotNull ()—— 建立的集合中不能插入null值

Set

建立一个不可变的Set

val mList = setOf (1,2,3)

建立一个可变的Set

val mList = mutableSetOf (1,2,3)

此外还有以下方法

• emptySet() ——建立一个空的set集合
• linkedSetOf()—— 建立set链表集合

Map

建立一个不可变的Map

val mList = mapOf(Pair("key1", 1), Pair("key2", 2))

或者

val mList = mapOf("key1" to 1, "key2" to 2)

建立一个可变的Map

val mList = mutableMapOf("key1" to 1, "key2" to 2)

推荐使用to的方式建立
此外还有

• emptyMap()——建立一个空map
• hashMapOf()——建立一个hashMap
• linkedMapOf()——建立一个linkedMap
• sortedMapOf()——建立一个sortedMap

以上就是三种集合常见的建立方式，下面再来讲说集合中的操做符，使用合适的操做符能够极大的减少你的代码量

操做符

总数操做

any

说明：若是至少有一个元素符合判断条件，则返回true，不然false,例：

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

结果为false

all

说明：若是集合中全部的元素都符合判断条件，则返回true不然false,例：

val list = listOf(1, 2, 3, 4, 5)
list.any { it < 10 }

结果为true

count

说明：返回集合中符合判断条件的元素总数。例：

list.count { it <3 }

结果为2

fold

说明：在一个初始值的基础上从第一项到最后一项经过一个函数累计全部的元素。例：

list.fold(0) { total, next -> total + next }

结果为15 (计算方式：0+1+2+3+4+5，第一个数0 为fold中的0，也就是初始值)

foldRight

说明：与fold同样，可是顺序是从最后一项到第一项。例：

list.foldRight(0) { total, next -> total + next }

结果也为15

reduce

说明：与fold同样，可是没有一个初始值。经过一个函数从第一项到最后一项进行累计。例：

list.reduce{ total, next -> total + next}

结果为15

reduceRight

说明：与foldRight同样，只不过没有初始值。例：

list.reduceRight { total, next -> total + next }

结果也为15

forEach

说明：遍历全部元素，并执行给定的操做（相似于Java 中的for循环）。例：

list.forEach{ Log.i(TAG,it.toString()) }

结果为：1 2 3 4 5

forEachIndexed

说明：与forEach做用同样，可是同时能够获得元素的index。例：

list.forEachIndexed { index, i -> Log.i(TAG, "index:" + index + " value:" + i.toString()) }

结果为
index:0 value:1
index:1 value:2
index:2 value:3
index:3 value:4
index:4 value:5

max

说明：返回集合中最大的一项，若是没有则返回null。例：

Log.i(TAG, list.max().toString())

结果为:5

min

说明：返回集合中最小的一项，若是没有则返回null。例：

Log.i(TAG, list.min().toString())

结果为:1

maxBy

说明：根据给定的函数返回最大的一项，若是没有则返回null。例：

Log.i(TAG, list.maxBy { it-10 }.toString())

结果为 ：5 （由于从1到5这5个元素中只有5减去10后的值最大，因此返回元素5，注意返回的不是计算结果）

minBy

说明：返回最小的一项，若是没有则返回null。例：

Log.i(TAG, list.minBy { it-10 }.toString())

结果为：1

sumBy

说明：返回全部每一项经过函数转换以后的数据的总和。例：

list.sumBy { it + 2 }

结果为：25 （每一个元素都加2，最后求和）

过滤操做

drop

说明：返回去掉前n个元素的列表。例：

val list = listOf(1, 2, 3, 4, 5)
var s = list.drop(2)
s.forEach {
Log.i(TAG, it.toString())
}

结果为 ：3 4 5（去掉了前两个元素）

dropWhile

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

list.dropWhile { it < 3 }

结果为：3 4 5

dropLastWhile

说明：同dropWhile，可是是从最后一项开始。例：

list.dropLastWhile { it >3 }

结果为:1 2 3

filter

说明：过滤全部符合给定函数条件的元素。例：

list.filter { it > 2 }

结果为：3 4 5

filterNot

说明：过滤全部不符合给定函数条件的元素。例：

list.filterNot{ it > 2 }

结果为：1 2

filterNotNull

说明：过滤全部元素中不是null的元素。例：

list.filterNotNull()

结果为：1 2 3 4 5

slice

说明：过滤集合中指定index的元素（其实就是获取指定index的元素)。例：

list.slice(listOf(0,1,2))

结果为：1 2 3

take

说明：返回从第一个开始的n个元素。例：

list.take(2)

结果为：1 2

takeLast

说明：返回从最后一个开始的n个元素。例：

list.takeLast(2)

结果为：4 5

takeWhile

说明：返回从第一个开始符合给定函数条件的元素。例：

list.takeWhile { it<3 }

结果为：1 2

映射操做

flatMap

说明：遍历全部的元素，为每个建立一个集合，最后把全部的集合放在一个集合中。例：

list.flatMap { listOf(it, it + 1) }

结果为： 1 2 2 3 3 4 4 5 5 6（每一个元素都执行加1后做为一个新元素）

groupBy

说明：返回一个根据给定函数分组后的map。例：

list.groupBy { if (it >3) "big" else "small" }

结果为：
small=[1, 2, 3]
big=[4, 5]

map

说明：返回一个每个元素根据给定的函数转换所组成的集合。例：

list.map { it * 2 }

结果为：2 4 6 8 10

mapIndexed

说明：返回一个每个元素根据给定的包含元素index的函数转换所组成的集合。例：

list.mapIndexed { index, it -> index + it }

结果为：1 3 5 7 9

mapNotNull

说明：返回一个每个非null元素根据给定的函数转换所组成的集合。例：

list.mapNotNull { it * 2 }

结果为：2 4 6 8 10

顺序操做

reversed

说明：返回一个与指定集合相反顺序的集合。例：

list.reversed()

结果为：5 4 3 2 1

sorted

说明：返回一个天然排序后的集合。例：

val list = listOf(1, 2, 6, 4, 5)
var s = list.sorted()

结果为 1 2 4 5 6

sortedBy

说明：返回一个根据指定函数排序后的集合。例：

val list = listOf(1, 2, 6, 4, 5)
var s = list.sortedBy { it - 2 }

结果为 1 2 4 5 6

sortedDescending

说明：返回一个降序排序后的集合。例：

list.sortedDescending()

结果为：5 4 3 2 1

sortedByDescending

说明：返回一个根据指定函数降序排序后的集合。例：

list.sortedByDescending { it % 2 }

结果为： 1 3 5 2 4

生产操做

partition

说明：把一个给定的集合分割成两个，第一个集合是由原集合每一项元素匹配给定函数条件返回true的元素组成，第二个集合是由原集合每一项元素匹配给定函数条件返回false的元素组成。例：

val list = listOf(1, 2, 3, 4, 5)
var s = list.partition { it > 2 }
s.first.forEach {
    Log.i(TAG, it.toString())
}
s.second.forEach {
    Log.i(TAG, it.toString())
}复制代码

结果为：
3 4 5
1 2

plus

说明：返回一个包含原集合和给定集合中全部元素的集合，由于函数的名字缘由，咱们可使用+操做符。例：

list + listOf(6, 7)

结果为： 1 2 3 4 5 6 7

zip

说明：返回由pair组成的List，每一个pair由两个集合中相同index的元素组成。这个返回的List的大小由最小的那个集合决定。例：

list.zip(listOf(7, 8))

结果为：(1, 7) (2, 8)

unzip

说明：从包含pair的List中生成包含List的Pair。例：

var s = listOf(Pair(1, 2), Pair(3, 4)).unzip()
s.first.forEach {
    Log.i(TAG, it.toString())
}
s.second.forEach {
    Log.i(TAG, it.toString())
}复制代码

结果为：1 2 3 4

元素操做

contains

说明：指定元素能够在集合中找到，则返回true，不然false。例：

list.contains(1)

结果为：true

elementAt

说明：返回给定index对应的元素，若是index数组越界则会抛出IndexOutOfBoundsException。例：

list.elementAt(1)

结果为：2

elementAtOrElse

说明：返回给定index对应的元素，若是index数组越界则会根据给定函数返回默认值。例：

list.elementAtOrElse(5, { it + 2 })

结果为：7

elementAtOrNull

说明：返回给定index对应的元素，若是index数组越界则会返回null。例：

list.elementAtOrNull(5)

结果为：null

first

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

list.first { it > 2 }

结果为：3

firstOrNull

说明：返回符合给定函数条件的第一个元素，若是没有符合则返回null。例：

list.first { it > 8 }

结果为：null

indexOf

说明：返回指定元素的第一个index，若是不存在，则返回-1。例：

list.indexOf(2)

结果为：1

indexOfFirst

说明：返回第一个符合给定函数条件的元素的index，若是没有符合则返回-1。例：

list.indexOfFirst { it % 2 == 0 }

结果为：1

indexOfLast

说明：返回最后一个符合给定函数条件的元素的index，若是没有符合则返回-1。例：

list.indexOfLast { it % 2 == 0 }

结果为：3

last

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

list.last { it % 2 == 0 }

结果为：4

lastIndexOf

说明：返回指定元素的最后一个index，若是不存在，则返回-1。例：

list.lastIndexOf(4)

结果为：3

lastOrNull

说明：返回符合给定函数条件的最后一个元素，若是没有符合则返回null。例：

list.lastOrNull { it > 6 }

结果为：null

single

说明：返回符合给定函数的单个元素，若是没有符合或者超过一个，则抛出异常。例：

list.single { it > 4 }

结果为：5

singleOrNull

说明：返回符合给定函数的单个元素，若是没有符合或者超过一个，则返回null。例：

list.singleOrNull { it > 5}

结果为：null