本文继续补充Kotlin集合高阶函数~

4.过滤操作符

• filter{...} : 过滤函数，返回满足指定条件的元素集合
• filterIndexed{...} : 与filter{}类似，在过滤时可以操作元素下标（index）
• filterNot{...} : 与filter{}相反
• filterNotNull() : 返回集合中不为null的元素集合，也就是过滤掉集合中的null元素
• take(num) : 返回集合中前num个元素组成的集合（针对所有Iterable容器）
• takeWhile{...} : 循环遍历集合，从第一个元素开始遍历，当出现一个不满足条件的元素时，退出遍历，返回遍历过程满足条件的元素（针对所有Iterable容器）
• takeLast(num) : 返回集合中后num个元素组成的集合（针对List）
• takeLastWhile{...} : 与takeWhile{...}类似，遍历是从最后一个元素开始（针对List）

• drop(num) : 过滤集合中前num个元素，返回剩余元素（针对所有Iterable容器）
• dropWhile{...} : 循环遍历集合，从第一个元素开始遍历，当出现一个不满足条件的元素时，退出遍历，返回除遍历过程满足条件的元素外的剩余元素（针对所有Iterable容器）
• dropLast(num) : 返回集合中除后num个元素外的其他元素（针对List）
• dropLastWhile{...} : 相同条件下，与takeLastWhile{...}得到的结果相反（针对List）

• distinct() : 去除重复元素
• distinctBy{...} : 根据操作元素后的结果去重，返回的集合元素顺序与原集合保持一致
• slice : 按元素下标过滤元素

示例：

val list = listOf("a", "bc", "def", "g", "hijk", "lmn")
println(list.take(2))  // [a, bc]
println(list.takeWhile { it.length < 4 })  // [a, bc, def, g]
println(list.takeLast(2))  // [hijk, lmn]
println(list.takeLastWhile { it.length < 4 })  // [lmn]
println(list.drop(2))  // [def, g, hijk, lmn]
println(list.dropWhile { it.length < 4 })  // [hijk, lmn]
println(list.dropLast(2))  // [a, bc, def, g]
println(list.dropLastWhile { it.length < 4 })  // [a, bc, def, g, hijk]
val list3 = listOf(1, 1, 2, 3, 3, 4, 5)
println(list3.distinct())  // [1, 2, 3, 4, 5]
println(list3.distinctBy { it % 2 })  // [1, 2]
println(list3.slice(0..2)) // [1, 1, 2]
println(list3.slice(listOf(2, 3, 4)))  // [2, 3, 3]

5.生产操作符

• plus() : 合并两个集合。对于可变集合，此操作会直接修改集合内容；对于不可变集合，它会返回一个新的合并后的集合。也可以使用符号+
• zip : 将两个集合的对应元素配对，形成一个新的集合，每个元素是一个Pair。如果两个集合长度不一致，结果集的长度将与较短的那个集合相同。
• unzip :与zip相反，将一个包含Pair的集合转换回两个集合。每个Pair的元素分别放入两个集合中。
• partition : 根据给定的条件将集合分为两个子集合：分别存放满足条件的元素和不满足条件的元素。

示例：

val list1 = listOf(1, 2, 3)
val list2 = listOf(4, 5)
val combined = list1 + list2 // combined 是 [1, 2, 3, 4, 5]
val names = listOf("Alice", "Bob")
val ages = listOf(24, 30)
val nameAgePairs = names.zip(ages) // nameAgePairs 是 [("Alice", 24), ("Bob", 30)]
val pairs = listOf("Alice" to 24, "Bob" to 30)
val (namesList, agesList) = pairs.unzip() // namesList 是 ["Alice", "Bob"], agesList 是 [24, 30]
val numbers = listOf(1, 2, 3, 4, 5)
val (even, odd) = numbers.partition { it % 2 == 0 } // even 是 [2, 4], odd 是 [1, 3, 5]

6.统计操作符

• any(),any{...} : 检查集合中是否有至少一个元素满足给定条件。无参数版any()用于判断集合是否非空。

val numbers = listOf(1, 2, 3, 4)
val hasEven = numbers.any { it % 2 == 0 } // true
val isEmpty = listOf<Int>().any() // false

• all{...} : 检查集合中的所有元素是否都满足给定条件

val numbers = listOf(2, 4, 6, 8)
val allEven = numbers.all { it % 2 == 0 } // true

• none(),none{...} : 集合中是否所有元素都不满足给定条件。无参数版none()判断集合是否为空

val numbers = listOf(1, 3, 5)
val noEven = numbers.none { it % 2 == 0 } // true
val isEmpty = listOf<Int>().none() // true

• max(),maxBy{...} : 返回集合中的最大值。max()适用于Comparable类型的集合，maxBy{...}接受一个lambda表达式来确定比较标准

val numbers = listOf(1, 3, 2)
val maxVal = numbers.maxOrNull() // 3
val maxByAbs = numbers.maxBy { -it } // 1，这里取负数，所以实际是最小值的绝对值最大

• min(), minBy{...} : 类似于max()和maxBy{...}, 但用于找到最小值

val numbers = listOf(1, 3, 2)
val minVal = numbers.minOrNull() // 1

• sum(), sumBy{...}, sumByDouble{...} : 计算集合元素的总和。sum()用于数值类型集合的直接求和。sumBy{...}和sumByDouble{...}则用于根据提供的函数计算总和

val numbers = listOf(1, 2, 3)
val directSum = numbers.sum() // 6
val mappedSum = numbers.sumBy { it * 2 } // 12

• average() : 计算集合中数值的平均值

val numbers = listOf(1.0, 2.0, 3.0)
val avg = numbers.average() // 2.0

• reduce{...},reduceIndexed{...},reduceRight{...}, reduceRightIndexed{...} :  对集合元素进行累积操作，可以自定义累积逻辑。reduceRight{...}和reduceRightIndexed{...}是从右到左累积

val numbers = listOf(1, 2, 3)
val product = numbers.reduce { acc, i -> acc * i } // 6, 累乘
val rightSum = numbers.reduceRight { acc, i -> acc + i } // 6, 从右到左累加

• fold{...},foldIndexed{...},foldRight{...},foldRightIndexed{...} : 类似于reduce，但第一个参数可以指定初始值。foldRight系列也是从右向左折叠。

val numbers = listOf(1, 2, 3)
val foldedWithInit = numbers.fold(10) { acc, i -> acc + i } // 16, 初始值10，累加