前言
本文主要介绍kotlin中有关集合的相关知识,本文篇幅较长，可以只看自己关系的部分即可。可作为方法说明使用。
集合的定义
kotlin中将集合分为不可变集合和可变集合,需要注意的是不可变集合不能够删除，添加和清空
//不可变集合
val listof = listOf(1, 2, 3)
val setof = setOf(1, 2, 3)
val mapOf = mapOf("1" to "One","2" to "two")
//可变集合
val mutableListOf = mutableListOf();
val mutableSetOf = mutableSetOf()
val mutableMapOf = mutableMapOf()
mutableListOf.add(1)
mutableSetOf.add(1)
mutableMapOf.put("1","One")
获取集合元素
集合中获取元素的常见方法如下
get():获取指定下标的数据,如果出现下标越界则会报错。
getOrNull()：获取指定下标的数据,如果出现下标越界则会返回null。
getOrElse()：获取指定下标的数据并指定默认函数处理下标越界。
first(...):获取第一个元素,如果没有元素则报错。
first{...}:按照一定条件返回第一个元素
firstOrNull()：获取第一个元素，没有没有获取到则返回null
firstOrNull{...}：按照一定条件获取第一个元素，没有没有获取到则返回null
last():获取最后一个元素，获取不到报错
last{}:按照一定条件返回最后一个元素，获取不到则报错
lastOrNull()：获取最后一个元素，获取不到返回null
lastOrNull{...}:按照一定条件获取最后一个元素，获取不到则返回null
indexOfFirst{...}:返回满足条件的第一个元素
indexOfLast{...}:返回满足条件的最后一个元素
single()：返回单个元素,当集合元素个数大于1或等于0时报错
singleOrNull()：返回单个元素，当元素为空或集合元素有多个元素是返回null
singleOrNull{...}:按照一定条件返回单个元素，如果集合为空或有对个满足条件的元素时则返回null
代码如下
var mutableList = mutableListOf(1, 2, 3,4);
for (any in mutableList) {
Log.e("mutableList", "$any")
}
//获取指定坐标的数据
val get = mutableList.get(0);
Log.e("get","$get")
//获取指定位置的元素，并指定下标越界后的执行方法
mutableList.getOrElse(1000,{Log.e("getOrElse","${it}下标越界")})
//获取指定坐标的数据，如果下标越界返回null
var orNull = mutableList.getOrNull(2000)
Log.e("getOrNull","$orNull")
//获取第一个元素
val first = mutableList.first()
Log.e("first","$first")
//指定获取第一个元素的条件
val first1 = mutableList.first { it > 2 }
Log.e("first","${first1}")
//获取第一个元素，如果没有返回null
val firstOrNull = mutableList.firstOrNull()
Log.e("firstOrNull","$firstOrNull")
val firstOrNull1 = mutableList.firstOrNull{it>3}
Log.e("firstOrNull","$firstOrNull1")
//获取最后一个元素
val last = mutableList.last();
Log.e("last","$last")
//按照一定条件返回最后一个元素
val last1 = mutableList.last { it < 3 }
Log.e("last","$last")
//获取最后最后一个元素,没有返回null
val lastOrNull = mutableList.lastOrNull()
Log.e("lastOrNull","$lastOrNull");
//按条件返回最后一个元素
val lastOrNull1 = mutableList.lastOrNull { it < 2 }
Log.e("lastOrNull1","$lastOrNull1")
//返回满足条件的第一个元素
val indexOfFirst = mutableList.indexOfFirst { it is Int }
Log.e("indexOfFirst","$indexOfFirst")
//返回满足条件的最后一个元素
val indexOfLast = mutableList.indexOfLast { it > 2 }
Log.e("indexOfLast","$indexOfLast")
// 返回单个元素,没有数据则报错,仅限于集合中只有一个或没有数据的情况下使用
/* val single = mutableList.single()
Log.e("single","$single")*/
//按条件返回单个元素,没有则报错
val single1 = mutableList.single { it > 3 }
Log.e("single","$single1")
// 返回单个元素,集合中有多个数据或没有数据则返回null
val singleOrNull = mutableList.singleOrNull();
Log.e("singleOrNull","$singleOrNull")
// 按条件返回单个元素,集合中有多个数据满足或没有数据则返回null
val singleOrNull1 = mutableList.singleOrNull { it < 1 }
Log.e("singleOrNull","$singleOrNull1")
测试结果如下
11-07 11:01:32.516 25736-25736/com.zhqy.javademo E/mutableList: 1
11-07 11:01:32.517 25736-25736/com.zhqy.javademo E/mutableList: 2
11-07 11:01:32.517 25736-25736/com.zhqy.javademo E/mutableList: 3
11-07 11:01:32.517 25736-25736/com.zhqy.javademo E/mutableList: 4
11-07 11:01:32.517 25736-25736/com.zhqy.javademo E/get: 1
11-07 11:01:32.517 25736-25736/com.zhqy.javademo E/getOrElse: 1000下标越界
11-07 11:01:32.527 25736-25736/com.zhqy.javademo E/getOrNull: null
11-07 11:01:32.527 25736-25736/com.zhqy.javademo E/first: 1
11-07 11:01:32.527 25736-25736/com.zhqy.javademo E/first: 3
11-07 11:01:32.527 25736-25736/com.zhqy.javademo E/firstOrNull: 1
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/firstOrNull: 4
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/last: 4
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/last: 4
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/lastOrNull: 4
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/lastOrNull1: 1
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/indexOfFirst: 0
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/indexOfLast: 3
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/single: 4
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/singleOrNull: null
11-07 11:01:32.528 25736-25736/com.zhqy.javademo E/singleOrNull: null
需要注意的是：获取函数最好使用OrXXX的方法或者带{}的函数来避免下标越界的等问题
排序
kotlin中常见的结合排序方法如下：
sortedBy{...}功能与上个方法一致，但不会改变集合的顺序，而是返回一个新的排好序的集合
reverse()：集合反序，即将当前集合中元素顺序反过来。比如说集合长度为10，使用该方法下标为0的放到下标为9的存储空间。
reversed():与上个方法功能一致，但不会改变集合的顺序，而是返回一个新的排好序的集合
sort()：将自然有序的数据以升序进行排列
sorted():与上个方法功能一致,但不会改变集合的顺序，而是返回一个新的排好序的集合
sortDescending()：将自然有序的数据以降序排列
sortedDescending():与上个方法功能一致,但不会改变集合的顺序，而是返回一个新的排好序的集合
sortByDescending{...}:按照一定条件给集合元素降序
sortedByDescending{...}:与上个方法功能一致,但不会改变集合的顺序，而是返回一个新的排好序的集合
这里只演示每种方法的第一个,代码如下
var students:MutableList = mutableListOf()
for (i in 20 downTo 10){
var student=Student("张三$i",i)
students.add(student)
}
//根据条件给集合升序，常用与给对象集合的某个字段排序
students.sortBy(Student::age)
for(student in students){
Log.e("sortBy","$student")
}
//集合反序。反序指的是和当前集合的元素顺序相反
students.reverse()
for(student in students){
Log.e("reverse","$student")
}
students.reversed()
//给自然有序的元素以升序排序
val nums = mutableListOf(10,9,9,7,6,5,4,3,2,1)
nums.sort()
for (num in nums){
Log.e("sort","$num")
}
//自然降序
nums.sortDescending()
nums.sortedDescending()
for (num in nums){
Log.e("sort","$num")
}
//根据条件给集合降序
students.sortByDescending { it.age }
for(student in students){
Log.e("sortedByDescending","$student")
}
测试结果如下
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三10, age=10)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三11, age=11)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三12, age=12)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三13, age=13)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三14, age=14)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三15, age=15)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三16, age=16)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三17, age=17)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三18, age=18)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三19, age=19)
11-07 11:16:32.955 26060-26060/? E/sortBy: Student(name=张三20, age=20)
11-07 11:16:32.966 26060-26060/? E/reverse: Student(name=张三20, age=20)
11-07 11:16:32.966 26060-26060/? E/reverse: Student(name=张三19, age=19)
11-07 11:16:32.966 26060-26060/? E/reverse: Student(name=张三18, age=18)
11-07 11:16:32.966 26060-26060/? E/reverse: Student(name=张三17, age=17)
11-07 11:16:32.966 26060-26060/? E/reverse: Student(name=张三16, age=16)
11-07 11:16:32.966 26060-26060/? E/reverse: Student(name=张三15, age=15)
11-07 11:16:32.966 26060-26060/? E/reverse: Student(name=张三14, age=14)
11-07 11:16:32.967 26060-26060/? E/reverse: Student(name=张三13, age=13)
11-07 11:16:32.967 26060-26060/? E/reverse: Student(name=张三12, age=12)
11-07 11:16:32.967 26060-26060/? E/reverse: Student(name=张三11, age=11)
11-07 11:16:32.967 26060-26060/? E/reverse: Student(name=张三10, age=10)
11-07 11:16:32.967 26060-26060/? E/sort: 1
11-07 11:16:32.967 26060-26060/? E/sort: 2
11-07 11:16:32.968 26060-26060/? E/sort: 3
11-07 11:16:32.968 26060-26060/? E/sort: 4
11-07 11:16:32.968 26060-26060/? E/sort: 5
11-07 11:16:32.968 26060-26060/? E/sort: 6
11-07 11:16:32.968 26060-26060/? E/sort: 7
11-07 11:16:32.968 26060-26060/? E/sort: 9
11-07 11:16:32.968 26060-26060/? E/sort: 9
11-07 11:16:32.968 26060-26060/? E/sort: 10
11-07 11:16:32.968 26060-26060/? E/sort: 10
11-07 11:16:32.968 26060-26060/? E/sort: 9
11-07 11:16:32.968 26060-26060/? E/sort: 9
11-07 11:16:32.968 26060-26060/? E/sort: 7
11-07 11:16:32.968 26060-26060/? E/sort: 6
11-07 11:16:32.968 26060-26060/? E/sort: 5
11-07 11:16:32.968 26060-26060/? E/sort: 4
11-07 11:16:32.969 26060-26060/? E/sort: 3
11-07 11:16:32.969 26060-26060/? E/sort: 2
11-07 11:16:32.969 26060-26060/? E/sort: 1
11-07 11:16:32.969 26060-26060/? E/sortedByDescending: Student(name=张三20, age=20)
11-07 11:16:32.969 26060-26060/? E/sortedByDescending: Student(name=张三19, age=19)
11-07 11:16:32.969 26060-26060/? E/sortedByDescending: Student(name=张三18, age=18)
11-07 11:16:32.969 26060-26060/? E/sortedByDescending: Student(name=张三17, age=17)
11-07 11:16:32.969 26060-26060/? E/sortedByDescending: Student(name=张三16, age=16)
11-07 11:16:32.969 26060-26060/? E/sortedByDescending: Student(name=张三15, age=15)
11-07 11:16:32.969 26060-26060/? E/sortedByDescending: Student(name=张三14, age=14)
11-07 11:16:32.969 26060-26060/? E/sortedByDescending: Student(name=张三13, age=13)
11-07 11:16:32.970 26060-26060/? E/sortedByDescending: Student(name=张三12, age=12)
11-07 11:16:32.970 26060-26060/? E/sortedByDescending: Student(name=张三11, age=11)
11-07 11:16:32.970 26060-26060/? E/sortedByDescending: Student(name=张三10, age=10)
需要注意的点
(1)千万不要把反序理解成了倒序
(2)sortBy方法是对原集合做排序操作，而sortedBy方法是返回一个排序后的新集合，原集合排序没有变
(3)kotlin排序方法中可以用and，or 组装多个条件，但效果并不理想
过滤函数
kotlin中常见的过滤函数如下:
filter{...}：按照一定的条件过滤集合，并返回过滤过的集合
filterNot{...}:返回过滤的元素集合
filterNotNull()：过滤掉集合中为null的元素
filterIndexed{...}:与filter功能类似，加入下标来进一步过滤数据
distinct()：去除集合中的重复数据
distinctBy{...}:根据一定的条件去重，返回的是需要去重数据的集合（不含重复元素）
take(num)：获取前num个元素
takeWhile{...}:从一个元素开始遍历，直到循环结束，返回遍历的元素集合
takelast(num)：获取后num个集合
takeLastWhile{...}：与takeWhile功能一致，只是从最后一个元素开始遍历
drop（num）:去除前num个元素
dropwhile{...}:从第一个元素开始，直到循环结束返回由过滤后的元素集合
示例代码如下
var list = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
//filter：过滤掉不符合条件的数据，返回符合条件的集合,不会改变原集合
val filter = list.filter { it > 5 };
Log.e("filter", filter.toString())
//filterNot：将过滤掉的数据以新集合的形式返回,不会改变原集合
val filterNot = list.filterNot { it > 5 }
Log.e("filterNot", filterNot.toString())
/*
filterNotNull：过滤掉集合中为null的元素
var containNull=mutableListOf("1","3")
val filterNotNull = containNull.filterNotNull()
*/
//filterIndexed: 与filter功能类似，但增加了下标来进一步过滤
val filterIndexed = list.filterIndexed { index, i -> index > 5 && i < 8 }
Log.e("filterIndexed", filterIndexed.toString())
//distinct:去除重复元素
var disList=mutableListOf(1,1,2,2,3,3)
val distinct = disList.distinct();
Log.e("distinct",distinct.toString())
//distinctBy:根据一定条件去重,获取的是需要去除的数据集合
val distinctBy = mutableListOf.distinctBy { it == 1 }
Log.e("distinctBy",distinctBy.toString())
//take(num): 返回前几个元素
val take = list.take(3);
Log.e("take",take.toString())
//takeWhile: 从第一个元素开始遍历，直到不满足循环添加返回遍历元素集合为止
val takeWhile = list.takeWhile { it < 5 }
Log.e("takeWhile",takeWhile.toString())
//takelast(num)：返回最后的num个元素
val takeLast = list.takeLast(3)
Log.e("takeLast",takeLast.toString());
//takeLastWhile 与takeWhile功能一致，只是从最后一个元素开始遍历
val takeLastWhile = list.takeLastWhile { it > 7 }
Log.e("takeLastWhile",takeLastWhile.toString())
//drop（num）:去除前num个元素
val drop = list.drop(3);
Log.e("drop",drop.toString())
//dropwhile:从第一个元素开始，直到循环结束返回由过滤后的元素集合
val dropWhile = list.dropWhile { it < 4 }
Log.e("dropWhile",dropWhile.toString())
测试结果
11-07 14:12:10.056 17459-17459/com.zhqy.javademo E/filter: [6, 7, 8, 9]
11-07 14:12:10.056 17459-17459/com.zhqy.javademo E/filterNot: [1, 2, 3, 4, 5]
11-07 14:12:10.056 17459-17459/com.zhqy.javademo E/filterIndexed: [7]
11-07 14:12:10.067 17459-17459/com.zhqy.javademo E/distinct: [1, 2, 3]
11-07 14:12:10.068 17459-17459/com.zhqy.javademo E/distinctBy: [1]
11-07 14:12:10.068 17459-17459/com.zhqy.javademo E/take: [1, 2, 3]
11-07 14:12:10.068 17459-17459/com.zhqy.javademo E/takeWhile: [1, 2, 3, 4]
11-07 14:12:10.068 17459-17459/com.zhqy.javademo E/takeLast: [7, 8, 9]
11-07 14:12:10.068 17459-17459/com.zhqy.javademo E/takeLastWhile: [8, 9]
11-07 14:12:10.068 17459-17459/com.zhqy.javademo E/drop: [4, 5, 6, 7, 8, 9]
11-07 14:12:10.069 17459-17459/com.zhqy.javademo E/dropWhile: [4, 5, 6, 7, 8, 9]
注意:以上的函数在执行完后都会返回一个新的集合,不会影响原集合
统计函数
Kotlin的常见统计函数如下：
max():获取集合中的最大值，如果集合为空则返回null
maxBy{...}:按照一定的条件获取最大值，如果没有则返回null
min():获取集合中的最小值，如果集合为空则返回null
minBy{...}:按照一定的条件获取最小值，如果没有则返回null
sum():返回集合的累加结果，返回值为Int
sumby{...}：按照一定的条件进行集合元素累加，返回为Int
sumByDouble{...}：与sumBy类似，返回值为Bouble
average()：对集合去平均值
reduce{...}:从集合的第一个元素到最后一个元素进行累积计算
reduceIndexed{...}:与reduce类似,添加了一个下标作为参数
reduceRight{...}:与reduce类似，但是从最后一个元素到第一个元素进行累积计算
reduceRightIndexed{...}:与reduceRight类似，但添加了下标作为参数
fold{...}：与reduce类似，添加了一个初始值
foldIndex{...}:与fold类似，添加了下标作为参数
foldRight{...}：与reduceRight，添加了一个初始值
foldRightIndex{...}：与foldRight类似，添加了一个下标作为
any{...}:只要有元素满足一定条件则返回true，否则返回false
all{...}：集合中的所有都满足一定的条件则返回true，否则返回false
none{...}:与all的功能相反，集合中的所有元素都不满足一定的条件则返回true，否则返回false
示例代码如下：
var listOf = mutableListOf(1, 2, 3, 4, 5)
var students = mutableListOf()
for (i in 20 downTo 10) {
var student = Student("张三", i)
students.add(student)
}
//max:获得集合中最大的元素，若集合为空则返回null
val max = listOf.max();
Log.e("max", "$max")
//maxBy:按照一定的条件获取集合的最大值.没有结果则返回null
val maxBy = students.maxBy { it.age }
Log.e("maxBy", "$maxBy");
//min:获取最小的元素,如果集合为空则返回null
val min = listOf.min();
Log.e("min", "$min")
//minBy:按照一定的条件获取集合的最小值，如果没有则返回null
val minBy = students.minBy { it.age }
Log.e("minBy", "$minBy")
//sum：对集合中的数据进行累加,返回值为Int类型
val sum = listOf.sum();
Log.e("sum", "$sum")
//sumBy:根据一定的条件求和，返回值为Int
val sumBy = listOf.sumBy { it - 1 }
Log.e("sumBy", "$sumBy")
//sumByDouble： 与sumBy相似，返回值为Double
val sumByDouble = listOf.sumByDouble { it - 2.0 }
Log.e("sumByDouble", "$sumByDouble")
//average:对集合取平均数
val average = listOf.average()
Log.e("average", "$average")
//reduce：从集合中的第一个元素到最后一个元素的累计操作
val reduce = listOf.reduce { acc, i -> acc * i }
Log.e("reduce", "$reduce")
//reduceIndexed:与reduce类似,添加了下标参数
val reduceIndexed = listOf.reduceIndexed { index, acc, i -> index + acc * i }
Log.e("reduceIndexed", "$reduceIndexed")
//reduceRight：功能与reduce相似，只是从最后一个元素进行累计操作开始
val reduceRight = listOf.reduceRight { i, acc -> i * acc };
Log.e("reduceRight", "$reduceRight")
//reduceRightIndexed： 与reduceRight类似,添加了下标参数
val reduceRightIndexed = listOf.reduceRightIndexed { index, i, acc -> index + i * acc }
Log.e("reduceRightIndexed", "$reduceRightIndexed")
//fold 功能与reduce类似，添加了初始值
val fold = listOf.fold(0, { acc, i -> acc * i })
Log.e("fold", "$fold")
//foldIndexed 与fold类似，添加了一个下标参数
val foldIndexed = listOf.foldIndexed(0, { index, acc, i -> acc * i })
Log.e("foldIndexed", "$foldIndexed")
//foldRight：与reduceRight相似，但它有一个初始值 acc初始值为1，即设置的初始值
val foldRight = listOf.foldRight(1, { i, acc -> i * acc })
Log.e("foldRight", "$foldRight")
//foldRightIndexed:与foldRight类似，添加了一个小标参数
val foldRightIndexed = listOf.foldRightIndexed(1, { index, i, acc -> i * acc })
Log.e("foldRightIndexed", "$foldRightIndexed")
//any：集合中是否有满足条件的元素，有的话返回true，否则返回false
val any = listOf.any { it % 2 == 0 }
Log.e("any", "$any")
//all:集合中所有的元素是否都满足条件，是的话返回true否则返回false
val all = listOf.all { it is Int }
Log.e("all", "$all")
//none：与all的作用相反
val none = listOf.none { it is Int }
Log.e("none", "$none");
测试结果
11-07 15:48:52.257 24465-24465/? E/max: 5
11-07 15:48:52.257 24465-24465/? E/maxBy: Student(name=张三, age=20)
11-07 15:48:52.257 24465-24465/? E/min: 1
11-07 15:48:52.257 24465-24465/? E/minBy: Student(name=张三, age=10)
11-07 15:48:52.257 24465-24465/? E/sum: 15
11-07 15:48:52.257 24465-24465/? E/sumBy: 10
11-07 15:48:52.258 24465-24465/? E/sumByDouble: 5.0
11-07 15:48:52.258 24465-24465/? E/average: 3.0
11-07 15:48:52.258 24465-24465/? E/reduce: 120
11-07 15:48:52.258 24465-24465/? E/reduceIndexed: 239
11-07 15:48:52.258 24465-24465/? E/reduceRight: 120
11-07 15:48:52.258 24465-24465/? E/reduceRightIndexed: 143
11-07 15:48:52.258 24465-24465/? E/fold: 0
11-07 15:48:52.258 24465-24465/? E/foldIndexed: 0
11-07 15:48:52.258 24465-24465/? E/foldRight: 120
11-07 15:48:52.259 24465-24465/? E/foldRightIndexed: 120
11-07 15:48:52.259 24465-24465/? E/any: true
11-07 15:48:52.259 24465-24465/? E/all: true
11-07 15:48:52.259 24465-24465/? E/none: false
需要注意的是，kotlin的统计函数可以实现简单的统计逻辑，复杂的操作还是放在函数中调用实现相应功能。
元素映射
通俗的说，映射就是将一个集合中的数据通过某种变换形成另一个集合的数据。kotlin中的元素映射常见函数有以下几种：
map：通过一定的条件将一个集合转换为另一个集合，并将该集合返回
mapNotNull:与map类似,但会过滤转换后为null的元素
mapIndexed:与map类似，添加了一个下标作为参数
mapIndexedNotNull：与mapIndexed类似，但会过滤转换后为null的元素
flatMap：通过一定的条件将两个集合转化为一个集合并返回该集合
groupBy:通过一定的条件将集合转换为Map
代码如下：
val listOf = mutableListOf(1, 2, 3, 4, 5)
//map:将集合中的元素通过一定的条件进行变换，返回变换后的集合
val map = listOf.map { it -> "@$it" }
Log.e("map", map.toString())
//mapNotNull:与map类似，但过滤掉转换后为null的数据
val mapNotNull = listOf.mapNotNull { it -> if (it == 2) null else it }
Log.e("mapNotNull", mapNotNull.toString())
//mapIndexed :与map功能类似，添加了一个下标参数
val mapIndexed = listOf.mapIndexed({ index, i -> "$index:$i" })
Log.e("mapIndexed", "$mapIndexed")
//mapIndexedNotNull：与mapIndexed功能类似，但会过滤转化后为null的元素
val mapIndexedNotNull = listOf.mapIndexedNotNull({ index, i -> if (i == 2) null else "$index:$i" })
Log.e("mapIndexedNotNull", "$mapIndexedNotNull")
//flatMap:将两个集合按照一定的条件转换为一个集合，并将这个集合返回
val odd = mutableListOf(1, 3, 5, 7, 9)
val flatMap = odd.flatMap { listOf(it, it + 1) }
Log.e("flatMap", flatMap.toString())
//groupBy：根据一定的条件将集合进行分组，并返回一个Map>的集合
val groupBy = listOf.groupBy { it -> it % 2 == 0 }
Log.e("groupBy", groupBy.toString())
测试结果如下
11-07 16:27:01.948 26943-26943/? E/map: [@1, @2, @3, @4, @5]
11-07 16:27:01.949 26943-26943/? E/mapNotNull: [1, 3, 4, 5]
11-07 16:27:01.949 26943-26943/? E/mapIndexed: [0:1, 1:2, 2:3, 3:4, 4:5]
11-07 16:27:01.949 26943-26943/? E/mapIndexedNotNull: [0:1, 2:3, 3:4, 4:5]
11-07 16:27:02.011 26943-26943/? E/flatMap: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
11-07 16:27:02.012 26943-26943/? E/groupBy: {false=[1, 3, 5], true=[2, 4]}
需要注意的点
(1)map方法不是集合遍历，集合遍历的方法是forEach。
(2)mapNotNull方法不是遍历集合不为null的方法，而是过滤转换后为null的元素。
(3)调用string.split()函数，无论用forEach还是map，即使没有内容还是会遍历一次。
联结函数
Kotlin的联结函数就是操作两个集合的差并补交的操作，常见的操作如下：
intersect：求两个集合的交集，并返回交集的集合
subtract：求两个集合的差集，并返回差集的集合
union:求两个集合的并集，并返回并集的集合
minus：求两个集合的补集，并返回补集的集合
示例代码如下
val first = listOf(1,3,4,6,7)
val second = listOf(1, 2, 3, 5, 6)
//intersect：求两个集合的交集，并返回交集的集合
val intersect = first.intersect(second);
Log.e("intersect",intersect.toString())
//subtract：求两个集合的差集，并返回差集的集合
val subtract = first.subtract(second);
Log.e("subtract",subtract.toString())
//union:求两个集合的并集，并返回并集的集合
val union = first.union(second);
Log.e("union",union.toString())
//minus：求两个集合的补集，并返回补集的集合
val minus = first.minus(second)
Log.e("minus",minus.toString())
测试结果
11-07 16:41:42.357 27518-27518/com.zhqy.javademo E/intersect: [1, 3, 6]
11-07 16:41:42.357 27518-27518/com.zhqy.javademo E/subtract: [4, 7]
11-07 16:41:42.358 27518-27518/com.zhqy.javademo E/union: [1, 3, 4, 6, 7, 2, 5]
11-07 16:41:42.358 27518-27518/com.zhqy.javademo E/minus: [4, 7]
总结
Kotlin集合的操作函数很多，以上仅列举了常见的函数，对于这些函数不需要死记硬背，需要在日常开发中慢慢熟悉。例如
(1)NotNull结尾的如果返回的不是集合则为没有返回是会返回null,返回的是集合则该集合中不会有null的元素
(2)如果方法返回的是集合，则该集合是新创建的集合，不会对原来的集合进行修改，如果没有返回集合则原先的集合进行了修改
(3)index结尾的会将集合下标作为参数。