一、前言

<font face= 黑体>在 Kotlin 高阶函数与内联函数 中咱们曾经将 Kotlin 的 高阶函数 和 内联函数 讲完了，明天咱们来讲 Kotlin 的 汇合变换与聚合。

二、汇合变换与聚合

2.1、汇合的变换操作

<font face= 黑体>对于汇合来说，最常见的应用形式就是对汇合进行遍历，咱们来看一下 Java 和 Kotlin 的遍历汇合代码：
Java:

// 一般的 for 循环遍历for(int i = 0; i <= 10; i++) {    System.out.println(i);}// for each 遍历for(int e : list) {    System.out.println(e);}// forEach 函数list.forEach((e) - > {    System.out.println(e);});

Kotlin:

// 一般的 for 循环遍历for(i in 0 .. 10) {    println(i)}// for each 遍历for(e in list) {    println(e);}// forEach 函数list.forEach {    println(it);}

<font face= 黑体>在下面的 forEach 函数外面不能 continue 或者 break，然而咱们有须要 break 和 continue 的需要要怎么办呢？其实咱们有专用的办法来解决这样的需要，就是汇合的 映射操作（Java 在 8 的时候也引入了这些操作，叫 流Stream），如下：

2.1.1、filter 操作

<font face= 黑体>比方咱们要从汇合 [1, 2, 3, 4] 中将所有的偶数筛选进去，就能够用 filter 操作来实现，如下：

Java:

 list.stream()     .filter(e -> e % 2 == 0);

Kotlin:

list.filter { it % 2 == 0 }

2.1.2、map 操作

<font face= 黑体>比方咱们要把汇合 [1, 2, 3, 4] 中的所有元素乘以 2，变成一个新汇合，就能够用 map 操作来实现，如下：

Java:

 list.stream()     .map(e -> e * 2);

Kotlin:

list.map { it * 2 }

<font face= 黑体>下面的 Kotlin 代码还能够写成上面这样：

list.asSequence().map { it * 2 }

<font face= 黑体>这两种写法区别次要是汇合的操作是饿汉式的还是懒汉式的，如果加上 asSequence 的话，汇合的操作就变成了懒序列了。咱们通过上面的代码来解释这两种形式：

Java:

List<Integer> list = new ArrayList<>();list.addAll(Arrays.asList(1, 2, 3, 4));list.stream()        .filter(e -> {        System.out.println("filter: " + e);        return e % 2 == 0;        })        .map(e -> {        System.out.println("map: " + e);        return e * 2 + 1;        })        .forEach(e -> {        System.out.println("forEach: " + e);        });

Kotlin:

val list = listOf(1, 2, 3, 4)list.asSequence()     .filter {         println("filter: $it")         it % 2 == 0     }.map {         println("map: $it")         it * 2 + 1     }.forEach {         println("forEach: $it")     }

<font face= 黑体>打印后果如下所示：

<font face= 黑体>从打印后果能够看出，懒序列的执行形式是汇合外面的 1 走一遍残缺的流程，走完之后 2 持续走一遍残缺的流程...，然而 1 呢在 filter 外面判断是不是偶数就不满足了，而后就是 2 走一遍残缺流程，2 是满足 filter 的过滤的，所以 2 就到了 map 外面映射成了 5，而后在 forEach 中输入了，3 和 4 都是同样的流程。

<font face= 黑体>如果咱们把 asSequence() 去掉，就变成了饿汉式，代码如下：

val list = listOf(1, 2, 3, 4)list    .filter {        println("filter: $it")        it % 2 == 0    }.map {        println("map: $it")        it * 2 + 1    }.forEach {        println("forEach: $it")    }

<font face= 黑体>从打印后果能够看出，饿汉式在调用 filter 的时候马上就会将汇合全副过滤一遍，而后过滤之后的在去执行 map，等所有元素 map 操作都执行好之后，在执行 forEach。

2.1.3、flatMap 操作

<font face= 黑体>flatMap 操作能够看上面的图解：

<font face= 黑体>flatMap 的操作就是将一个元素映射成汇合，而后再将这些汇合合并起来。

2.2、汇合的聚合操作

<font face= 黑体>汇合除了有上述的变换操作外，汇合还有聚合操作，如下：

<font face= 黑体>Kotlin 的汇合的聚合操作相比来讲没有变换操作重要，这里我就举个 fold 函数的例子吧，如下：

// 计算过程为 10 + 1 + 2 + 3,等于 16val foldResult1 = arrayOf(1, 2, 3).fold(10, { a, b -> a + b }) println(foldResult1)//计算过程为 10 * 1 * 2 * 3,等于60val foldResult2 = arrayOf(1, 2, 3).fold(10, { a, b -> a * b })println(foldResult2)

<font face= 黑体>fold 函数的操作如下：

1. <font face= 黑体>第一次执行时,由初始值 10 作为参数 a，由汇合中第 0 个元素作为参数 b；
2. <font face= 黑体>第二次执行时,第一次执行的返回值作为参数 a，由汇合中第 1 个元素作为参数 b；
3. <font face= 黑体>顺次类推...;
4. <font face= 黑体>最终将后果返回。

三 、小结

<font face= 黑体>本篇博客次要讲了 Kotlin 中的汇合的变换与聚合，下一节咱们讲 Kotin 的 SAM 转换 和 罕用高阶函数。

四、源码

源码 已上传至 github，有须要能够间接下载。