Kotlin 聚合操作

Kotlin 提供了多种聚合操作来对集合中的元素进行处理。本文将介绍 Kotlin 中常用的聚合操作及其用法。

集合的聚合操作

在 Kotlin 中，集合的聚合操作包括过滤、映射、排序、分组、归约等。

过滤操作

过滤操作用于筛选出集合中符合一定条件的元素。常用的过滤操作包括 filter 和 filterNot：

val list = listOf(1, 2, 3, 4, 5)
val filteredList = list.filter { it % 2 == 0 }
println(filteredList) // 输出 [2, 4]

上述代码中，filter 方法接收一个 lambda 表达式，这个表达式用于对每个元素进行条件判断，符合条件的元素保留在列表中，不符合条件的元素则被过滤掉。filterNot 方法则是将过滤条件取反，保留不符合条件的元素。

映射操作

映射操作用于将每个元素按照某种规则映射成一个新的元素。常用的映射操作包括 map 和 flatMap：

val list = listOf("hello", "world", "kotlin")
val mappedList = list.map { it.toUpperCase() }
println(mappedList) // 输出 [HELLO, WORLD, KOTLIN]

上述代码中，map 方法接收一个 lambda 表达式，这个表达式将每个元素映射成一个新的元素，并将这些新元素组成一个新列表返回。flatMap 方法则将每个元素映射成一个新的集合，并将所有新集合中的元素组成一个新列表返回。

排序操作

排序操作用于按照某种规则对集合中的元素进行排序。常用的排序操作包括 sorted 和 sortedBy：

data class Person(val name: String, val age: Int)

val list = listOf(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 20))
val sortedList = list.sortedBy { it.age }
println(sortedList) // 输出 [Person(name=Charlie, age=20), Person(name=Alice, age=25), Person(name=Bob, age=30)]

上述代码中，sortedBy 方法接收一个 lambda 表达式，这个表达式用于对每个元素进行排序规则的计算。sorted 方法则是按照元素自然顺序进行排序。

分组操作

分组操作用于将集合中的元素按照某种规则进行分组。常用的分组操作包括 groupBy：

data class Person(val name: String, val age: Int)

val list = listOf(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 20))
val groupedMap = list.groupBy { it.age }
println(groupedMap) // 输出 {25=[Person(name=Alice, age=25)], 30=[Person(name=Bob, age=30)], 20=[Person(name=Charlie, age=20)]}

上述代码中，groupBy 方法接收一个 lambda 表达式，这个表达式用于对每个元素进行分组规则的计算。groupBy 返回一个 Map 对象，这个 Map 中的 key 是分组规则的计算结果，value 是一个 List，表示符合该分组规则的所有元素。

归约操作

归约操作用于将集合中的所有元素进行某种运算，并得到运算结果。常用的归约操作包括 reduce 和 fold：

val list = listOf(1, 2, 3, 4, 5)
val sum = list.reduce { acc, i -> acc + i }
println(sum) // 输出 15

上述代码中，reduce 方法接收一个二元运算符 lambda 表达式，这个表达式用于对集合中的元素进行归约，返回运算结果。fold 方法则和 reduce 方法类似，不同的是它接收一个初始值参数。

延迟序列的聚合操作

除了对集合进行操作外，Kotlin 还支持对延迟序列进行聚合操作。延迟序列是一种惰性求值的数据结构，它只在需要时才产生元素。

过滤操作

与集合类似，延迟序列也支持过滤操作。常用的过滤操作包括 filter 和 filterNot：

val sequence = sequenceOf(1, 2, 3, 4, 5)
val filteredSequence = sequence.filter { it % 2 == 0 }
println(filteredSequence.toList()) // 输出 [2, 4]

上述代码中，filter 方法还是接收一个 lambda 表达式，与集合不同的是它返回的是一个延迟序列。需要将延迟序列转换成列表时，可以通过 toList 方法实现。

映射操作

映射操作也是与集合类似，常用的映射操作包括 map 和 flatMap：

val sequence = sequenceOf("hello", "world", "kotlin")
val mappedSequence = sequence.map { it.toUpperCase() }
println(mappedSequence.toList()) // 输出 [HELLO, WORLD, KOTLIN]

上述代码中，map 方法也还是接收一个 lambda 表达式，与集合不同的是它返回的是一个延迟序列。flatMap 方法则与集合中的 flatMap 方法类似。

排序操作

排序操作也是与集合类似，常用的排序操作包括 sorted 和 sortedBy：

data class Person(val name: String, val age: Int)

val sequence = sequenceOf(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 20))
val sortedSequence = sequence.sortedBy { it.age }
println(sortedSequence.toList()) // 输出 [Person(name=Charlie, age=20), Person(name=Alice, age=25), Person(name=Bob, age=30)]

上述代码中，sortedBy 方法也还是接收一个 lambda 表达式，与集合不同的是它返回的是一个延迟序列。sorted 方法则与集合中的 sorted 方法类似。

分组操作

分组操作也是与集合类似，常用的分组操作包括 groupBy：

data class Person(val name: String, val age: Int)

val sequence = sequenceOf(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 20))
val groupedMap = sequence.groupBy { it.age }
println(groupedMap) // 输出 {25=[Person(name=Alice, age=25)], 30=[Person(name=Bob, age=30)], 20=[Person(name=Charlie, age=20)]}

上述代码中，groupBy 方法也还是接收一个 lambda 表达式，与集合不同的是它返回的是一个延迟序列。

归约操作

归约操作也是与集合类似，常用的归约操作包括 reduce 和 fold：

val sequence = sequenceOf(1, 2, 3, 4, 5)
val sum = sequence.reduce { acc, i -> acc + i }
println(sum) // 输出 15

上述代码中，reduce 方法也还是接收一个二元运算符 lambda 表达式，与集合不同的是它返回的是一个延迟序列。fold 方法也是与 reduce 方法类似，不同的是它接收一个初始值参数。

总结

本文介绍了 Kotlin 中常用的集合和延迟序列的聚合操作。这些操作可以使程序员更加方便地对集合和序列中的元素进行处理。掌握这些操作会提高程序员的代码效率和程序的可读性。