Kotlin 集合系列

1.创建集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tKOmtkVq-1596380268243)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/96668d69-74ea-4a33-90c5-eff8db36317d/2020-07-295.50.22.png)]

2.集合操作

2.1 Filter系列

filter系列的操作分为以下两类

• filterXXX传入一个lambada并返回一个新的list
• filterXXXTo是将一个集合过滤后追加到另一个集合后面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-quCSasr0-1596380268251)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/54ee465a-933f-456d-a77c-800e4ebdf080/2020-07-297.04.29.png)]

2.2 Slice系列

Slice系列仅有以下两个Api:

var y = mutableListOf(1,2,3,4,5,6,7)
var z = y.slice(listOf(1, 4))  //z = [2, 5]
var z = y.slice(IntRange(1, 4)) //z = [2, 3, 4, 5]

以列表为参数时，返回一个新的列表，列表的值为原始列表指定index下的值

以IntRange为参数时，返回一个新的列表，列表的值为IntRange指定的index闭区间的值

2.3 While系列

while系列表示从列表的一端开始遍历，直到有第一个是lambada返回true时停止，并返回符合条件的新列表，带Last的api表示倒序，否则表示正序。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PCa1UnRk-1596380268255)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/07f106c9-4d5a-4dca-accd-c1f71c97e7f5/2020-07-297.16.37.png)]

举例说明：

var ret1 = y.takeLastWhile { i -> i < 3 }
var ret2 = y.dropWhile { i -> i < 3 }
var ret3 = y.dropWhile { i -> i > 3 }

输出如下：

[1]
[3, 4, 5, 6, 7, 1]
[1, 2, 3, 4, 5, 6, 7, 1]

2.4 Map系列

map系列函数的功能是将一个集合映射成为另一个集合，其中flatmap原始集合的元素和结果集合的元素是一对多的关系，其余为一对一的关系。flatmap将映射结果暂存在一个集合里面，最终合并所有的结果集合，map直接将元素的映射结果作为返回，xxxMapTo是将结果追加到另一个集合里。

举例说明：

var y = mutableListOf(1,2,3,4,5,6,7,1)
var ret1 = y.map { i -> "==${i}==" }
var ret2 = y.flatMap { i -> arrayListOf<Int>(i+100, i) }
var z2 = mutableListOf<Int>(999, 998, 997)
var ret3 = y.mapTo(z2) { i -> i + 100 }

输出如下：

[==1==, ==2==, ==3==, ==4==, ==5==, ==6==, ==7==, ==1==]
[101, 1, 102, 2, 103, 3, 104, 4, 105, 5, 106, 6, 107, 7, 101, 1]
[999, 998, 997, 101, 102, 103, 104, 105, 106, 107, 101]

2.5 Window/Chunked系列

想象有一个宽为n的窗口，在一个数组上从左到右滑过，每次移动一个步都会生成一个长度为n的数组，window系列函数就是返回所有这些窗口数组组成的新数组。可以方便的实现滑动窗口算法。

window系列有两个重载：

public fun <T> Iterable<T>.windowed(size: Int, step: Int = 1, partialWindows: Boolean = false): List<List<T>>

Untitled

另一个重载额外接受一个变化函数lambada，将窗口数组作为入参，映射成新的元素：

public fun <T, R> Iterable<T>.windowed(size: Int, step: Int = 1, partialWindows: Boolean = false, transform: (List<T>) -> R)

举例说明：

var y = mutableListOf(1,2,3,4,5,6,7)
var ret1 = y.windowed(2)
var ret2 = y.windowed(2, step = 2, partialWindows = true)
var ret3 = y.windowed(2) {input -> input.sum()}

结果如下：

[[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7]]
[[1, 2], [3, 4], [5, 6], [7]]
[3, 5, 7, 9, 11, 13]

chunked则是直接调用的window

@SinceKotlin("1.2")
public fun <T> Iterable<T>.chunked(size: Int): List<List<T>> {
    return windowed(size, size, partialWindows = true)
}

2.6 Associate系列

associate系列函数负责将一个集合映射成为map，和其他集合方法一样，以To结尾的函数是将结果追加到另一个集合中，从此不再单独讨论。associtate只接受一个变换函数lambada

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TdakO2D4-1596380268277)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/17adb266-09d7-4bfe-a2d5-eb939996037a/2020-07-3010.49.18.png)]

返回Pair的情况，即相当于返回了Java中的Map.Entry。

associateBy是以输入集合元素为map的Value。

associateWith是以输入集合元素为map的Key。

举例说明：

var y = mutableListOf(4,3,2,1)
var ret1 = y.associate { i -> Pair(i, "Str$i") }
var ret2 = y.associateBy { i -> "Str${i}" }
var ret3 = y.associateWith { i -> "Str${i}" }

输出如下

{4=Str4, 3=Str3, 2=Str2, 1=Str1}
{Str4=4, Str3=3, Str2=2, Str1=1}
{4=Str4, 3=Str3, 2=Str2, 1=Str1}

2.7 增删（minus/remove/plus/add）

remove/add比较简单不再展开，以minus为例：

minus(element: T)完全等价于minusElement。返回一个新集合。

minusAssign完全等价于remove。在原始集合上直接操作。

但要注意minus(elements: Iterable)是删除原集合中所有在参数集合中的元素，举例说明

var y = mutableListOf(4,2,3,2,1)
var ret1 = y.minus(2)
var ret2 = y.minus(listOf(2))

输出：

[4, 3, 2, 1]
[4, 3, 1]

2.8 Fold/Reduce系列

fold/ruduce能够帮助实现此集合上的聚合操作，所谓聚合操作就是将整合集合映射成一个值，reduce接受的lambada有两个入参，一个是上一步操作的结果，一个是当前的元素。比如可以这样实现求和：

{ sum, element -> sum + element }

fold提供一个初始值，其余和reduce一致，带有Right的重载表示反向遍历集合，带有Index的重载表示入参多了index：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RAHWtxlH-1596380268284)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/e11ef748-a275-4851-bf75-9eb1f070cb38/2020-07-3011.46.48.png)]