Kotlin基础(7)-集合

前言

本文主要介绍kotlin中有关集合的相关知识,本文篇幅较长，可以只看自己关系的部分即可。可作为方法说明使用。

集合的定义

kotlin中将集合分为不可变集合和可变集合,需要注意的是不可变集合不能够删除，添加和清空

        //不可变集合
        val listof = listOf<Int>(1, 2, 3)
        val setof = setOf<Int>(1, 2, 3)
        val mapOf = mapOf<String, String>("1" to "One","2" to "two")

        //可变集合
        val mutableListOf = mutableListOf<Int>();
        val mutableSetOf = mutableSetOf<Int>()
        val mutableMapOf = mutableMapOf<String, String>()
        
        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<Int>(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<Student> = 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<Int>(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<Int>(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<Any>("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<Int>(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<Int>(1, 2, 3, 4, 5)
        var students = mutableListOf<Student>()

        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<K,List<T>>的集合

代码如下：

val listOf = mutableListOf<Int>(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<Int>(1, 3, 5, 7, 9)
        val flatMap = odd.flatMap { listOf(it, it + 1) }
        Log.e("flatMap", flatMap.toString())

        //groupBy：根据一定的条件将集合进行分组，并返回一个Map<K,List<T>>的集合
        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<Int>(1,3,4,6,7)
        val second = listOf<Int>(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结尾的会将集合下标作为参数。