集合是开发中非常常用的知识，比如操作各种数据集，各种算法，保存网络请求结果等，如果你不会集合的知识，那么可能连显示一个基本的ListView列表都做不到，今天就来说说Kotlin中集合的知识。
Kotlin中集合操作符大致可分为6大类，分别是：

• 统计操作符
• 元素操作符
• 顺序操作符
• 映射操作符
• 过滤操作符
• 生成操作符

注意：在Kotlin中数组和list的操作符基本共同，所以在数组中可用的操作符也可以在list中使用。

统计操作符

• any 只要有一个符合就返回true
• all 所有条件符合才返回true
• count 返回符合条件的数目
• none 如果没有任何元素与给定的函数匹配，则返回true
• max 返回最大值
• min 返回最小值
• fold 在一个初始值的基础上 从第一项到最后一项通过 一个函数操作 所有的元素
• reduce 从第一项到最后一项通过 一个函数操作 所有的元素，相对于fold，没有初始值
• sum 求数组中所有值的和

    val array = arrayOf(1, 2, 3, 4, 5, 6, 7)
    println("any,数组中有值等于7，${array.any { it == 7 }}")
    println("all,数组中是否所有值都大于3，${array.all { it > 3 }}")
    println("count,数组中大于5的值有几个，${array.count { it > 5 }}")
    println("none,数组中没有大于9的数，${array.none { it > 9 }}")
    println("max,数组中的最大值，${array.max()}")
    println("min,数组中的最小值，${array.min()}")
    println("fold操作符的例子，${array.fold(4) { returnValue, next -> returnValue + next }}")
    //相对于fold操作符，相当于返回值的初始值为0
    println("reduce操作符的例子，${array.reduce { returnValue, next -> returnValue + next }}")
    println("sum,求数组中所有值的总和(也可以用 fold和reduce操作实现)，${array.sum()}")

any,数组中有值等于7，true
all,数组中是否所有值都大于3，false
count,数组中大于5的值有几个，2
none,数组中没有大于9的数，true
max,数组中的最大值，7
min,数组中的最小值，1
fold操作符的例子，32
reduce操作符的例子，28
sum,求数组中所有值的总和(也可以用 fold和reduce操作实现)，28

元素操作符

• contains,数组中是否包含某个元素
• first,返回第一个满足给定条件的元素
• firstOrNull,报错要判空处理；
• last,返回最后一个满足给定条件的元素
• indexOf,返回某个值在数组中的下标值
• elementAt,返回数组中某个下标的值
• single,返回数组中的满足条件的一个元素，如果没有或者满足条件的有多个就抛出异常
• find,找到第一个符合条件的值并返回

val array = arrayOf(1, 2, 3, 4, 5, 6, 7)
println("contains,数组中是否包含值为5的元素，${array.contains(5)}")
println("first,返回第一个满足给定条件的元素,大于3的条件，${array.first { it > 3 }}")
println("last,返回最后一个满足给定条件的元素，大于5的条件，${array.last { it > 5 }}")
println("indexOf,返回值为3在数组中的下标值，${array.indexOf(3)}")
println("elementAt,返回数组中下标为2的值，${array.elementAt(2)}")
println("single,返回数组中的满足条件的一个元素，如果没有或者满足条件的有多个就抛出异常，${array.single{it >6}}")
println("find,数组中的元素值，${array.find { it==7 }}")

contains,数组中是否包含值为5的元素，true
first,返回第一个满足给定条件的元素,大于3的条件，4
last,返回最后一个满足给定条件的元素，大于5的条件，7
indexOf,返回值为3在数组中的下标值，2
elementAt,返回数组中下标为2的值，3
single,返回数组中的满足条件的一个元素，如果没有或者满足条件的有多个就抛出异常，7
find,数组中的元素值，7

顺序操作符

• reversed，返回一个具有相反顺序的数组
• shuffled，返回一个随机顺序的数组
• sorted，返回一个升序的排序的数组
• sortedDescending，返回一个降序排序的数组
• sortedBy，根据指定的值进行升序排序
• sortByDescending，根据指定的值进行降序排序

fun <T> Array<T>.toStringExt(): String {
    val sb = StringBuilder("[")
    for ((index, value) in this.withIndex()) {
        sb.append(value)
        sb.append(",")
    }
    sb.delete(sb.length - 1, sb.length)
    sb.append("]")
    return sb.toString()
}

 data class Person(val age: Int, val weight: Int, val name: String) {
        override fun toString(): String {
            return "{$age,$weight,${name}}"
        }
}

fun main() {
    val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("reversed，返回一个具有相反顺序的数组，${array.reversed()}")
    println("shuffled，返回一个随机顺序的数组，${array.toList().shuffled()}")
    println("sorted，返回一个升序的排序的数组，${array.sorted()}")
    println("sortedDescending，返回一个降序排序的数组，${array.sortedByDescending { it }}")
    val persons = arrayOf(
            Person(18, 45, "小红"),
            Person(16, 50, "小绿"),
            Person(22, 48, "小紫"),
            Person(18, 50, "小蓝")
        )
    persons.sortBy { it.age }
    println("sortedBy，根据指定的值进行升序排序，${persons.toStringExt()}")
    persons.sortByDescending { it.weight }
    println("sortByDescending，根据指定的值进行降序排序，${persons.toStringExt()}")
}

reversed，返回一个具有相反顺序的数组，[7, 6, 3, 4, 5, 2, 1]
shuffled，返回一个随机顺序的数组，[4, 7, 1, 6, 3, 2, 5]
sorted，返回一个升序的排序的数组，[1, 2, 3, 4, 5, 6, 7]
sortedDescending，返回一个降序排序的数组，[7, 6, 5, 4, 3, 2, 1]
sortedBy，根据指定的值进行升序排序，[{16,50,小绿},{18,45,小红},{18,50,小蓝},{22,48,小紫}]
sortByDescending，根据指定的值进行降序排序，[{16,50,小绿},{18,50,小蓝},{22,48,小紫},{18,45,小红}]

映射操作符

• map，返回一个列表，其中包含将给定 函数 应用于原始数组中每个元素的结果
• slice，返回具有给定索引的集合元素列表，索引既可以是作为区间传入的也可以是作为整数值的集合传入的
• chunked，将此序列拆分为一系列列表，每个列表不超过给定的size，结果序列中的最后一个列表的元素可能少于给定的size
• flatMap，返回在原始数组的每个元素上调用 函数 的结果，所产生的所有元素的单个列表（flatMap的传入函数的返回必须是可迭代的 Iterable），flatMap的主要主要就是把多层的集合平铺成一层的
• flatten，返回给定集合中所有集合的所有元素的单个列表，相当于flatmap中的函数不对元素进行任何操作
• groupBy，按照给定的元素进行分组，返回的是一个map

 val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("map1: ${array.map { it % 2 == 0 }}")
    println("map2: ${array.map { it + 3 }}")
    println("slice: ${array.slice(1..5)}")
    println("slice: ${array.slice(listOf(1, 3, 0))}")
    println("chunked: ${array.toList().chunked(3)}")
    val array1 = mutableListOf(mutableListOf(1, 5, 9),mutableListOf(11, 40, 21), mutableListOf(3, 15, 10), mutableListOf(6, 8, 10))
    println("array1 = $array1")
    //平铺array1中的数据 并过滤掉 大于等于10的数据
    println("flatMap: ${array1.flatMap { it -> it.filter { it < 10 } }}")
    println("flatten: ${array1.flatten()}")
    val persons = arrayOf(Person(16,45,"小红"),Person(16,50,"小绿"),Person(18,45,"小紫"),Person(18,50,"小蓝"))
    println("groupBy_age: ${persons.groupBy{it.age}}")
    println("groupBy_weight: ${persons.groupBy{it.weight}}")

map1: [false, true, false, true, false, true, false]
map2: [4, 5, 8, 7, 6, 9, 10]
slice: [2, 5, 4, 3, 6]
slice: [2, 4, 1]
chunked: [[1, 2, 5], [4, 3, 6], [7]]
array1 = [[1, 5, 9], [11, 40, 21], [3, 15, 10], [6, 8, 10]]
flatMap: [1, 5, 9, 3, 6, 8]
flatten: [1, 5, 9, 11, 40, 21, 3, 15, 10, 6, 8, 10]
groupBy_age: {16=[{16,45,小红}, {16,50,小绿}], 18=[{18,45,小紫}, {18,50,小蓝}]}
groupBy_weight: {45=[{16,45,小红}, {18,45,小紫}], 50=[{16,50,小绿}, {18,50,小蓝}]}

过滤操作符

• filter，返回数组中符合给定条件的元素列表
• filterNot，过滤出所有不满足条件的元素
• filterNotNull，过滤出非NULL的元素
• take，返回包含前n个元素的列表
• drop，返回包含除前n个元素外的所有元素的列表

 val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("filter：${array.filter { it < 7 }}")
    println("take：${array.take(5)}")
    println("take：${array.take(10)}")
    println("drop：${array.drop(3)}")

filter：[1, 2, 5, 4, 3, 6]
take：[1, 2, 5, 4, 3]
take：[1, 2, 5, 4, 3, 6, 7]
drop：[4, 3, 6, 7]

生成操作符

• plus，返回一个在原数组的基础上，追加了一个新元素的新数组，原数组没有改变
• partition，返回一个Pair 其中包含两个列表，第一个列表时符合给定条件的列表，第二个列表时不合符条件的列表（类似于filter ，只是把过来后的元素组成了一个列表一起返回了）
• zip，将两个数组进行和并，返回一个Pair的list ，pair中包含有两个数组中相同下标的元素，返回的list的长度，由最短的数组决定（也可以自定义返回列表中的类型）

data class Day(val day: Int, val name: String) {
        override fun toString(): String {
            return "{$day,${name}}"
        }
    }

fun <T> Array<T>.toStringExt(): String {
    val sb = StringBuilder("[")
    for ((index, value) in this.withIndex()) {
        sb.append(value)
        sb.append(",")
    }
    sb.delete(sb.length - 1, sb.length)
    sb.append("]")
    return sb.toString()
}

fun main() {
    val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("array：${array.toStringExt()}")
    println("plus：${array.plus(19).toStringExt()}")
    println("partition：${array.partition { it < 5 }}")
    val array1 = arrayOf("今天", "明天", "后天", "天天都爱你")
    println("zip1：${array.zip(array1)}")
    println("zip2：${array.zip(array1) { a, b -> Day(a,b) }}")  
}

array：[1,2,5,4,3,6,7]
plus：[1,2,5,4,3,6,7,19]
partition：([1, 2, 4, 3], [5, 6, 7])
zip1：[(1, 今天), (2, 明天), (5, 后天), (4, 天天都爱你)]
zip2：[Day ={1,今天}, Day ={2,明天}, Day ={5,后天}, Day ={4,天天都爱你}]