前言

今天给大家带来Kotlin系列的第四篇文章，集合操作，在Kotlin中，集合主要有以下几种

• Iterable：父类。任何类继承这个接口就表示可以遍历序列的元素。

• MutableIterable：在迭代期间支持移除项目的迭代。

• Collection：这个类表示元素的泛型集合。我们可以访问函数：返回集合尺寸、集合是否为空、包含一项或一组。由于集合是不可变的，这类集合的所有方法只能请求数据。

• MutableCollection：支持添加和移除元素的Collection。它提供额外的函数，如：add、remove或clear等等。

• List：或许这是最常用的集合。这表示有序的元素泛型集合。由于是有序的，我们可以用get函数，按照项目的位置请求项目。

• MutableList：支持添加和移除元素的List。

• Set：不支持重复元素的无序元素集合。

• MutableSet：支持添加和移除元素的Set。

• Map：key-value 键-值对集合。在映射表（map）中key（键）是唯一的，就是说在一个映射表中不能有两对有相同的key。

• MutableMap：支持添加和移除元素的Map。

演示

给大家带来这一篇集合操作的目的就是让大家写出更加简介的代码，举个例子

比如我们现在有一个集合students，集合里面有10个数据，数据的id是0到9，我们判断其中是否有一个id等于5，如果有就返回true
java代码

for (Student student : students) {
     if (student.getId() == 5){
          return true;
      }
 }
 return false;

kotlin代码

return students.any { it.id == 5 }

看到差别了么，同样的逻辑在kotlin中只需要一行代码。

好戏开场

这里我先定义一个集合，下面会用到

val list = listOf(0, 1, 2, 3, 4, 5, 6, 7)

聚合操作

• any——判断集合中是否有满足条件的元素，有就返回true。

println(list.any { it % 2 == 1 })
打印结果：true

• all——如果集合中的元素都满足条件，就返回true。

println(list.all { it % 2 == 1 })
打印结果：false

• none——如果集合中的元素都不满足条件，则返回true

println(list.none { it % 2 == 10 })
打印结果：true

• count——查询集合中满足条件的元素个数

println(list.count { it % 2 == 1 })
打印结果：4

• forEach——遍历元素，元素是it(你也可以随便取名字)，可对每个元素进行相关操作

list.forEach { it -> if (it > 6) println(it) }
打印结果：7

• forEachIndexed——-遍历元素，同时得到元素index(索引)

list.forEachIndexed { index, it -> if (it > 6) println("大于6的值是$it索引是$index") }
打印结果：大于6的值是7索引是7

• max——-返回最大元素。如果没有元素，则返回null

println(list.max())
打印结果：7

• min——查询最小的元素，如果没有则返回null

println(list.min())
打印结果：0

• fold——在给定初始值的基础上，从第一项到最后一项进行累加

//比如这里我给的初始值为10
println(list.fold(10) { total, next -> total + next })
打印结果：38

• foldRight——在给定初始值的基础上，从最后一项到第一项进行累加，与fold只是的方向不同；

//比如这里我给的初始值为10
println(list.foldRight(10) { total, next -> total + next })
打印结果：38

• reduce——同fold，区别就是没有初始值

println(list.reduce { total, next -> total + next })
打印结果：28

• rreduceRight——同reduce，只不过是从最后一项到第一项进行累加

println(list.reduceRight { total, next -> total + next })
打印结果：28

• sumBy——返回集合中元素进转换后产生值的总和

println(list.sumBy { it % 2 })
打印结果：4

过滤操作

• drop——返回第N个元素之后的所有列表，但不包括第N个元素

println(list.drop(4))
//去掉了0，1，2，3这4个元素
打印结果：[4, 5, 6, 7] 

• dropWhile——从第一项起，去掉满足条件的元素，直到不满足条件的一项为止，返回剩下所有的元素

println(list.dropWhile { it < 5 })
打印结果：[5，6，7] 

• dropLastWhile——从最后一项起，去掉满足条件的元素，直到不满足条件的一项为止，返回剩下所有的元素

println(list.dropLastWhile { it < 7 })
//因为7<5不满足，所以直接停止，返回所有集合
打印结果：[0，1，2，3，4，5，6，7] 

• filter——过滤掉所有不满足条件的元素

println(list.filter { it % 2 == 0 })
打印结果：[0，2，4，6] 

• filterNot——过滤掉所有满足条件的元素

println(list.filterNot { it % 2 == 0 })
打印结果：[1，3，5，7] 

• filterNotNull——过滤掉所有值为null的元素

println(list.filterNotNull())
打印结果：[0，1，2，3，4，5，6，7] 

• take——从第一项开始，返回N个元素

println(list.take(3))
打印结果：[0，1，2] 

• takeLast——从最后一项开始，返回N个元素

println(list. takeLast(3))
打印结果：[5，6，7] 

• takeWhile——从第一项开始，返回N个元素，直到不满足条件为止

println(list.takeWhile { it < 3 })
打印结果：[0，1，2] 

映射操作

• flatMap——合并两个集合，可以在合并的时候对迭代元素值it做想要的操作

println(list.flatMap { listOf(it, it + 2) })
打印结果：[0，2，1，3，2，4，3，5，4，6，5，7，6，8，7，9] 

• groupBy——将集合中的元素按照某个条件分组，返回Map

println(list.groupBy { if (it % 2 == 0) "偶数和0" else "奇数" })
打印结果：{偶数和0=[0, 2, 4, 6], 奇数=[1, 3, 5, 7]}

• map——将集合中的元素通过某个方法转换后的结果存到一个集合中

println(list.map { it + 1 })
打印结果：[1，2，3，4，5，6，7，8] 

• mapIndexed——除了得到转换后的结果，还可以拿到index(索引)

println(list.mapIndexed { index, it -> index + it })
打印结果：[0，2，4，6，8，10，12，14] 

• mapNotNull——执行方法转换前过滤掉为null的元素

println(list.mapNotNull { it + 1 })
打印结果：[1，2，3，4，5，6，7，8] 

元素操作

• contains——判断集合中是否有指定元素，有则返回true

println(list.contains(3))
打印结果：true

• elementAt——返回指定索引位置的元素。如果索引超出这个集合的范围，则抛出IndexOutOfBoundsException。

println(list.elementAt(1))
打印结果：1

• elementAtOrElse——查找索引对应元素，如果越界会根据方法返回默认值

println(list.elementAtOrElse(9, { it }))
打印结果：9

• elementAtOrNull——返回索引位置的元素。如果索引超出这个集合的范围，则返回null

println(list.elementAtOrNull(9))
打印结果：null

• first——返回符合条件的第一个元素，没有则会抛NoSuchElementException异常

println(list.first { it % 2 == 0 })
打印结果：0

• firstOrNull——返回符合条件的第一个元素，没有返回null

println(list.firstOrNull { it % 2 == 100 })
打印结果：null

• last——返回符合条件的最后一个元素，没有则会抛NoSuchElementException异常；

println(list.last { it % 2 == 0 })
打印结果：6

• lastIndexOf——返回列表中指定元素的最后一次出现的索引，如果没有元素返回-1

println(list.lastIndexOf(5))
打印结果：5

• lastOrNull——返回符合条件的最后一个元素，没有返回null

println(list.lastOrNull { it % 2 == 100 })
打印结果：null

• indexOf——根据元素找索引，如何集合没有包含元素，则返回-1

println(list.indexOf(3))
打印结果：3

• indexOfFirst——返回第一个符合条件元素的索引，没有返回-1

println(list.indexOfFirst { it % 2 == 0 })
打印结果：0

• indexOfLast——返回最后一个符合条件元素的索引，没有返回-1

println(list.indexOfLast { it % 2 == 0 })
打印结果：6

• single——返回符合条件的单个元素，如有没有符合的或符合超过一个分别会抛NoSuchElementException或IllegalArgumentException异常

println(list.single { it % 7 == 2 })
打印结果：2

• singleOrNull——返回符合条件的单个元素，如有没有符合或超过一个，返回null

println(list.singleOrNull { it % 7 == 100 })
打印结果：null

生成操作

• partition——将原始集合拆分两个集合，一个集合包含判断条件为true的元素，另一个集合包含判断条件为false的元素

println(list.partition { it % 2 == 0 })
打印结果：([0, 2, 4, 6], [1, 3, 5, 7])

• plus——将两个List合并成一个，由于函数名称原因，我们可以使用“+”操作符

println(list.plus(listOf(8,9)))
打印结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

println(list.zip(listOf(5, 6, 7)))
打印结果：[(0, 5), (1, 6), (2, 7)]

排序操作

• reverse——集合逆序

println(list.reversed())
打印结果：[7, 6, 5, 4, 3, 2, 1, 0]

• sorted——升序

println(list.sorted())
打印结果：[0, 1, 2, 3, 4, 5, 6, 7]

• sortedBy——按照条件计算之后再升序排列

println(list.sortedBy {it % 3})
打印结果：[0, 3，6，1，4，7，2，5]

• sortedDescending——降序

println(list.sortedDescending())
打印结果：[7, 6, 5, 4, 3, 2, 1, 0]

• sortedByDescending——按照条件计算之后再降序排列

println(list.sortedByDescending{it % 3})
打印结果：[2，5，1，4，7，0，3，6]

总结

以上就是Kotlin语言的集合及相关操作，希望该文能帮助大家更好的使用Kotlin，可以更加快速高效的进行安卓开发。
哇，写了好久终于写完了，看到这里了你还不点个赞么0_0

以上纯属于个人平时工作和学习的一些总结分享，如果有什么错误欢迎随时指出，大家可以讨论一起进步。