Kotlin学习笔记二十一、集合的变换与序列以及聚合

集合的变换与序列

这一节主要是记录集合list、map、array等的filter()、map()、flatMap()函数的使用。这些函数在日常开发中有着重要的地位。

1、map的map()、 filter()方法：

val mMap: MutableMap<String, String> = mutableMapOf("01" to "02", "13" to "35", "15" to "36", "03" to "45")

将mMap的key和value拼接在一起形成新的字符串，返回一个list

var mapMap = mMap.map {
    //这里其实就是一个高阶函数的lambda表达式函数
    it.key + it.value
}
println("mapMap：${mapMap}")

过滤掉mMap的所有key里面包含“3”的字符串，然后返回一个新的map

var filterMapKey = mMap.filter {
    "3" !in it.key
}
println("filterMapKey：${filterMapKey}")

过滤掉mMap的所有value里面包含“3”的字符串，然后返回一个新的map

var filterMapValue = mMap.filter {
    "3" !in it.value
}
println("filterMapValue：${filterMapValue}")

从上面的运行结果，我们可以知道：

1、map的map()方法是将map的每一组“Entry”按照“{}”里面的表达式，组合成一个新的元素，然后将这些元素组合成一个新的list集合返回

2、map的filter()方法是按照“{}”里面的表达式“过滤”map中的每一组“Entry”，然后将剩下的“Entry”组成一个新的map返回

2、list的map()、 filter()方法：

集合list的filter方法是按照“{}”里面的表达式“过滤”集合中的每个元素，然后再将剩下的元素组成一个新的集合返回

var filterArray = mIntArray.filter {
    //这里其实就是一个高阶函数的lambda表达式函数
    it % 3 != 0
}
println("filterArray：${filterArray.joinToString()}")

运行结果：

集合list的map()方法是将list的每隔元素按照“{}”里面的表达式映射出一个新的元素，最后再将新的元素凭借成一个新的集合

var mapArray = mIntArray.map {
    it * 2
}
println("mapArray：${mapArray.joinToString()}")

list先调用asSequence(其实他就是一个懒序列)，关于懒序列，见下图。

mIntArray.asSequence().filter {
    it > 2
}.map {
    it % 3 != 2
}.forEach {
    println("链式调用：it===$it")
}

其实上面的forEach是一个链式调用，相当于由一下两部分调用：

var sequenceArray =  mIntArray.asSequence().map {
    it + 3
}
sequenceArray.forEach {
    println("分段调用：it===$it")
}

运行结果如下：

3、flatMap()方法：

var flatMapList = mIntArray.flatMap {       
    //下面我们做了两次转换，但是lambda表达式只认最后一个有效的表达式。
//        0 .. it
    (0 until it).asSequence().toList()
}
println("flatMapList：${flatMapList.joinToString()}")

将[0, it]区间范围内的每隔元素组成一个集合，最后拼接成一个新的集合。

比如mIntArray(2, 5, 6)，那么：

1、当it = 2时，得到一个元素为0、1、2的集合；
2、当it = 5时，得到一个元素为0、1、2、3、4、5的集合；
3、当it = 6时，得到一个元素为0、1、2、3、4、5、6的集合；

最终拼接成的新的list集合为：0, 1, 2, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6

val mStrArray: Array<String> = arrayOf("q、we、r", "as、df", "zxc、v")
var newStrArray = mStrArray.flatMap {
    //因为flatMap要求的是返回一个list，因此要求“{}”内部返回的也是一个类list，包括数组、list、Range等。
    it.split("、")

}
println("newStrArray：$newStrArray")

小结：

map集合的map()方法、list集合的map()方法返回的都是一个新的list集合；
map集合的filter()方法返回的是一个新的map集合；
list集合的filter()方法返回的还是一个list集合；

集合的聚合

这块也是分三部分，但相对于上一块，要简单很多：

1、sum()函数

sum()函数很简单，而且也只有数字型的集合和数组才会有这个方法：

val mIntArray: Array<Int> = arrayOf(2, 5, 6)
var sum = mIntArray.sum()
println("sum==$sum")

val mStrArray: Array<String> = arrayOf("9", "33", "956")
sum = mStrArray.sumBy {
    it.toInt()
}
println("sum==$sum")

运行结果：

2、fold()函数

表示按照fold()函数后面的“{}”内的规则重组后生成的新元素：

fold()方法后面的“{}”内 ：

acc类型：表示按照“{}”内的规则重组后生成的新元素；跟我们传入fold()方法里面的参数类型一致。但跟我们初始化的数据类型（比如这里的数组mIntArray）不一定一致

i含义：表示调用者的元素，比如上面的数组mIntArray，i分别是2、5、6

重点：

1、acc类型跟我们初始化的数据类型（比如这里的数组mIntArray）不一定一致。

2、跟我们传入fold()方法里面的参数类型一致。

var foldStr = mIntArray.fold(""){acc, i ->
    println("i=== $i，acc===$acc")
    acc+i
}
println("foldStr：$foldStr")
var foldStrBuf = mIntArray.fold(StringBuffer()){
    acc, i -> acc.append(i).append("*")
}
println("foldStrBuf：$foldStrBuf")

运行结果：

3、reduce()函数

其实reduce（）函数跟fold（）函数大同小异：

val mIntArray: Array<Int> = arrayOf(2, 5, 6)
var reduce = mIntArray.reduce { acc, i ->
    println("i=== $i，acc===$acc")
    acc.times(3)
}
println("reduce：$reduce")

reduce()方法后面的“{}”内 ：

acc类型：表示按照“{}”内的规则重组后生成的新元素；

acc类型跟我们初始化的数据类型（比如这里的数组mIntArray）一致。

i含义：表示调用者的元素，比如上面的数组mIntArray，i分别是2、5、6

序列

关于这块，上传一个图来理解吧：

具体代码可以在上面的“filter()”方法调用出查看。