在这里插入图片描述

目录

  1. 概述
  2. 基础聚合
  3. 高级聚合
  4. 数据统计
  5. 实战案例
  6. 性能优化
  7. 常见问题

概述

本文档介绍如何在 Kotlin Multiplatform (KMP) 鸿蒙跨端开发中进行聚合操作和数据统计。聚合操作是将集合中的多个元素合并为单个值的过程。通过 KMP，这些聚合操作可以无缝编译到 JavaScript，在 OpenHarmony 应用中高效运行。

为什么需要学习聚合操作？

  • 数据统计：计算总和、平均值、最大值等统计信息
  • 数据分析：对数据进行聚合分析和汇总
  • 性能优化：一次遍历完成多个统计操作
  • 代码简洁：使用函数式聚合比循环更清晰
  • 跨端兼容：聚合操作在编译到 JavaScript 时表现出色，完美支持 OpenHarmony
  • 代码复用：一份 Kotlin 代码可同时服务多个平台

基础聚合

sum - 求和

计算集合中所有元素的总和。

val numbers = listOf(1, 2, 3, 4, 5)
val sum = numbers.sum()
println(sum)  // 15

val doubles = listOf(1.5, 2.5, 3.5)
val doubleSum = doubles.sum()
println(doubleSum)  // 7.5

这段代码演示了如何使用 sum() 函数计算集合中所有元素的总和。第一个例子创建一个包含 1 到 5 的整数列表，调用 sum() 函数计算总和，结果为 15。第二个例子创建一个包含浮点数的列表，调用 sum() 函数计算总和，结果为 7.5。sum() 函数会自动遍历集合中的所有元素并累加，返回总和。这个函数支持整数、浮点数等数值类型，是最常用的聚合操作之一。

average - 平均值

计算集合中所有元素的平均值。

val numbers = listOf(1, 2, 3, 4, 5)
val average = numbers.average()
println(average)  // 3.0

val count = numbers.size
val avg = numbers.sum().toDouble() / count
println(avg)  // 3.0

这段代码演示了如何计算集合的平均值。第一个例子使用 average() 函数直接计算平均值，结果为 3.0。第二个例子展示了手动计算平均值的方式：先获取集合的大小，然后将总和除以元素个数。注意使用 toDouble() 将整数转换为浮点数，确保计算结果是浮点数而不是整数。两种方式的结果相同，但 average() 函数更简洁高效。average() 函数返回 Double 类型，即使集合中的元素是整数。

maxOrNull / minOrNull - 最大值和最小值

找出集合中的最大值和最小值。

val numbers = listOf(5, 2, 8, 1, 9, 3)

val max = numbers.maxOrNull()
println(max)  // 9

val min = numbers.minOrNull()
println(min)  // 1

// 处理空集合
val empty = emptyList<Int>()
val maxEmpty = empty.maxOrNull()
println(maxEmpty)  // null

这段代码演示了如何找出集合中的最大值和最小值。maxOrNull() 函数返回集合中的最大元素，如果集合为空则返回 null。minOrNull() 函数返回集合中的最小元素，如果集合为空则返回 null。这两个函数都使用 “OrNull” 后缀，表示可能返回 null 值。在处理可能为空的集合时，这种设计比抛出异常更安全。可以使用 Elvis 操作符 ?: 提供默认值，例如 max ?: 0。

count - 计数

计算集合中满足条件的元素个数。

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

// 计算总数
val total = numbers.count()
println(total)  // 10

// 计算偶数个数
val evenCount = numbers.count { it % 2 == 0 }
println(evenCount)  // 5

// 计算大于 5 的数字个数
val greaterThan5 = numbers.count { it > 5 }
println(greaterThan5)  // 5

这段代码演示了如何使用 count() 函数计数。第一个例子调用 count() 不带参数，返回集合中的总元素个数，结果为 10。第二个例子使用 count() 带 Lambda 表达式，计算满足条件（偶数）的元素个数，结果为 5。第三个例子计算大于 5 的数字个数，结果也是 5。count() 函数比 filter().size 更高效，因为它只计数而不创建新的集合。当需要统计满足特定条件的元素个数时，count() 是最佳选择。

高级聚合

fold - 折叠聚合

从初始值开始，逐个处理集合中的元素。

Kotlin 源代码
@OptIn(ExperimentalJsExport::class)
@JsExport
fun foldExample(): String {
    val numbers = listOf(1, 2, 3, 4, 5)
    
    // 求和
    val sum = numbers.sum()
    
    // 求积（使用 fold）
    val product = numbers.fold(1) { acc, value -> acc * value }
    
    // 最大值
    val max = numbers.maxOrNull() ?: 0
    
    // 最小值
    val min = numbers.minOrNull() ?: 0
    
    return "数字: ${numbers.joinToString(", ")}\n" +
           "求和: $sum\n" +
           "求积: $product\n" +
           "最大值: $max\n" +
           "最小值: $min"
}

这是聚合操作的核心实现函数，展示了多种聚合操作的综合使用。函数使用 @OptIn(ExperimentalJsExport::class) 和 @JsExport 注解，使其可以被编译成 JavaScript 并在 ArkTS 中调用。函数创建一个包含 1 到 5 的整数列表。使用 sum() 计算所有元素的总和，结果为 15。使用 fold() 函数计算所有元素的乘积，初始值为 1，Lambda 表达式 { acc, value -> acc * value } 将累加器与当前元素相乘，结果为 120。使用 maxOrNull() 获取最大值，如果为空则使用 Elvis 操作符 ?: 返回 0。使用 minOrNull() 获取最小值，如果为空则返回 0。最后使用字符串模板和 joinToString() 格式化输出结果。这个函数展示了如何综合使用多种聚合操作进行数据统计。

编译后的 JavaScript 代码
function foldExample() {
  var numbers = listOf([1, 2, 3, 4, 5]);
  var sum_0 = sum(numbers);
  
  // Inline function 'kotlin.collections.fold' call
  var accumulator = 1;
  var _iterator__ex2g4s = numbers.b();
  while (_iterator__ex2g4s.c()) {
    var element = _iterator__ex2g4s.d();
    // Inline function 'foldExample.<anonymous>' call
    var acc = accumulator;
    accumulator = imul_0(acc, element);
  }
  var product = accumulator;
  
  var tmp0_elvis_lhs = maxOrNull(numbers);
  var max = tmp0_elvis_lhs == null ? 0 : tmp0_elvis_lhs;
  var tmp1_elvis_lhs = minOrNull(numbers);
  var min = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
  
  return '数字: ' + joinToString_0(numbers, ', ') + '\n' + 
         ('求和: ' + sum_0 + '\n') + 
         ('求积: ' + product + '\n') + 
         ('最大值: ' + max + '\n') + 
         ('最小值: ' + min);
}

这段代码是 Kotlin 编译器生成的 JavaScript 代码，展示了 Kotlin 聚合操作如何被转换为 JavaScript。listOf() 函数创建一个列表。sum() 函数计算总和。fold() 操作被转换为一个 while 循环，使用累加器 accumulator 初始化为 1，然后遍历集合中的每个元素，执行乘法操作。maxOrNull() 和 minOrNull() 函数被调用，使用三元操作符处理 null 值（Elvis 操作符的 JavaScript 等价物）。字符串拼接使用 + 操作符。joinToString() 函数将列表元素转换为逗号分隔的字符串。这个编译过程展示了 KMP 如何将高级的 Kotlin 聚合操作转换为高效的 JavaScript 代码。

ArkTS 调用代码
import { foldExample } from './hellokjs';

@Entry
@Component
struct Index {
  @State message: string = '加载中...';
  @State results: string[] = [];

  aboutToAppear(): void {
    this.loadResults();
  }

  loadResults(): void {
    try {
      // 调用 Kotlin 编译的 JavaScript 函数
      const foldResult = foldExample();
      this.results = [foldResult];
      this.message = '案例已加载';
    } catch (error) {
      this.message = `错误: ${error}`;
    }
  }

  build() {
    Column() {
      Text('Kotlin Fold 聚合操作演示')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin({ top: 20, bottom: 20 })

      Text(this.message)
        .fontSize(14)
        .fontColor(Color.Gray)
        .margin({ bottom: 15 })

      Scroll() {
        Column() {
          ForEach(this.results, (result: string) => {
            Text(result)
              .fontSize(12)
              .fontFamily('monospace')
              .padding(12)
              .width('100%')
              .backgroundColor(Color.White)
              .border({ width: 1, color: Color.Gray })
              .borderRadius(8)
          })
        }
        .width('100%')
        .padding({ left: 15, right: 15 })
      }
      .layoutWeight(1)
      .width('100%')

      Button('刷新结果')
        .width('80%')
        .height(40)
        .margin({ bottom: 20 })
        .onClick(() => {
          this.loadResults();
        })
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#f5f5f5')
  }
}

这段 ArkTS 代码是鸿蒙应用的用户界面实现，展示了如何在 ArkTS 中导入和调用编译后的 Kotlin 函数。首先使用 import 语句从编译后的 JavaScript 模块中导入 foldExample 函数。使用 @State 装饰器定义两个响应式状态变量：message 用于显示状态信息，results 存储聚合操作的结果。aboutToAppear() 生命周期函数在组件加载时自动调用 loadResults() 进行初始化。loadResults() 方法调用 Kotlin 编译的 JavaScript 函数 foldExample()，获取聚合结果，然后更新 results 和 message。使用 try-catch 块捕获异常。build() 方法构建整个 UI 布局，包含标题、状态信息、可滚动的结果显示区域和刷新按钮。使用 ForEach 遍历 results 数组，为每个结果创建一个 Text 组件。整个界面占满屏幕，背景色为浅灰色。

执行流程说明
  1. Kotlin 源代码：定义 foldExample() 函数，使用 fold、sum、maxOrNull 等聚合操作
  2. 编译过程：Gradle 使用 KMP 编译器将 Kotlin 代码编译成 JavaScript
  3. JavaScript 输出：编译器生成优化的 JavaScript 代码，使用循环和累加器实现 fold 逻辑
  4. ArkTS 调用：在 OpenHarmony 应用中导入并调用编译后的 JavaScript 函数
  5. 结果展示：在 UI 中显示聚合结果

reduce - 化简聚合

使用第一个元素作为初始值进行聚合。

val numbers = listOf(1, 2, 3, 4, 5)

// 求和（使用 reduce）
val sum = numbers.reduce { acc, value -> acc + value }
println(sum)  // 15

// 求最大值
val max = numbers.reduce { acc, value -> if (acc > value) acc else value }
println(max)  // 5

// 空集合会抛出异常
val empty = emptyList<Int>()
// empty.reduce { acc, value -> acc + value }  // 异常

这段代码演示了如何使用 reduce() 函数进行化简聚合。reduce() 函数使用集合的第一个元素作为初始值，然后逐个处理后续元素。第一个例子使用 reduce() 计算所有元素的总和，Lambda 表达式 { acc, value -> acc + value } 将累加器与当前元素相加，结果为 15。第二个例子使用 reduce() 计算最大值，Lambda 表达式比较累加器和当前元素，返回较大的值，结果为 5。与 fold() 不同，reduce() 没有初始值参数，它使用第一个元素作为初始值。如果集合为空，reduce() 会抛出异常，这是与 fold() 的主要区别。因此，在处理可能为空的集合时，应该使用 fold() 而不是 reduce()。

数据统计

基础统计

val numbers = listOf(10, 20, 30, 40, 50)

// 计数
val count = numbers.size
println(count)  // 5

// 求和
val sum = numbers.sum()
println(sum)  // 150

// 平均值
val average = numbers.average()
println(average)  // 30.0

// 最大值和最小值
val max = numbers.maxOrNull() ?: 0
val min = numbers.minOrNull() ?: 0
println("Max: $max, Min: $min")  // Max: 50, Min: 10

这段代码展示了基础的数据统计操作。创建一个包含 10、20、30、40、50 的列表。使用 size 属性获取集合的元素个数，结果为 5。使用 sum() 函数计算所有元素的总和，结果为 150。使用 average() 函数计算平均值，结果为 30.0（返回 Double 类型）。使用 maxOrNull() 获取最大值 50，使用 minOrNull() 获取最小值 10。如果集合为空，这两个函数会返回 null，使用 Elvis 操作符 ?: 提供默认值 0。这些基础统计操作是数据分析的基础，在实际应用中非常常见。

条件统计

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

// 统计偶数
val evenCount = numbers.count { it % 2 == 0 }
val evenSum = numbers.filter { it % 2 == 0 }.sum()
val evenAverage = numbers.filter { it % 2 == 0 }.average()

println("偶数个数: $evenCount")  // 5
println("偶数总和: $evenSum")    // 30
println("偶数平均值: $evenAverage")  // 6.0

这段代码展示了如何进行条件统计。创建一个包含 1 到 10 的列表。使用 count() 函数统计满足条件（偶数）的元素个数，结果为 5。使用 filter() 过滤出所有偶数，然后调用 sum() 计算偶数的总和，结果为 30（2+4+6+8+10）。使用 filter() 过滤出所有偶数，然后调用 average() 计算偶数的平均值，结果为 6.0。这种模式在实际应用中很常见，例如统计满足特定条件的数据。注意 count() 比 filter().size 更高效，因为它不需要创建中间集合。

实战案例

案例：聚合操作的实际应用

在上面的"高级聚合"部分已经展示了完整的三层代码示例（Kotlin、JavaScript、ArkTS）。这个 foldExample() 案例演示了：

  1. 基础聚合：使用 sum、maxOrNull、minOrNull 进行统计
  2. 高级聚合：使用 fold 进行自定义聚合（求积）
  3. 编译过程：展示了 Kotlin 代码如何编译成 JavaScript
  4. 实际调用：展示了如何在 ArkTS 中调用编译后的函数
扩展应用场景

在实际项目中，可以基于 foldExample() 的模式进行扩展：

  • 财务统计：计算收入总额、平均值、最大值等
  • 成绩分析：统计学生成绩的总分、平均分、最高分、最低分
  • 销售数据：聚合销售数据进行统计分析
  • 日志分析：统计日志中的各类信息

所有这些应用都遵循相同的 Kotlin → JavaScript → ArkTS 的编译和调用流程。

性能优化

1. 选择合适的聚合函数

// ✅ 好：使用专门的函数
val sum = numbers.sum()
val max = numbers.maxOrNull()
val count = numbers.count()

// ❌ 不好：使用 fold 实现
val sum = numbers.fold(0) { acc, x -> acc + x }
val max = numbers.fold(Int.MIN_VALUE) { acc, x -> if (acc > x) acc else x }
val count = numbers.fold(0) { acc, _ -> acc + 1 }

这段代码展示了选择合适聚合函数的重要性。第一组代码使用专门的函数：sum() 计算总和，maxOrNull() 获取最大值，count() 计算元素个数。这些函数是为特定目的优化的，代码简洁清晰。第二组代码使用 fold() 实现相同的功能，虽然功能相同，但代码更复杂且性能较差。使用 fold() 需要指定初始值（如 Int.MIN_VALUE），容易出错。专门的函数不仅代码更清晰，而且编译器可以进行更好的优化。因此，在有专门函数可用时，应该优先使用专门函数而不是 fold()。

2. 避免重复遍历

// ❌ 不好：多次遍历
val sum = numbers.sum()
val max = numbers.maxOrNull()
val min = numbers.minOrNull()

// ✅ 好：一次遍历完成多个统计
data class Stats(val sum: Int, val max: Int, val min: Int)
val stats = numbers.fold(Stats(0, Int.MIN_VALUE, Int.MAX_VALUE)) { acc, x ->
    Stats(acc.sum + x, maxOf(acc.max, x), minOf(acc.min, x))
}

这段代码展示了性能优化的重要性。第一组代码分别调用 sum()、maxOrNull() 和 minOrNull()，每个函数都会遍历整个集合一次，共三次遍历。第二组代码定义一个 Stats 数据类来存储多个统计值，然后使用 fold() 一次遍历完成所有统计操作。在 fold() 的 Lambda 表达式中，同时计算总和、最大值和最小值。这种方法只需要一次遍历，性能提升显著，特别是在处理大数据集时。对于需要多个统计值的场景，使用 fold() 进行一次遍历是最优的选择。

3. 使用 Sequence 处理大数据

// ✅ 好：使用 Sequence 延迟计算
val result = numbers
    .asSequence()
    .filter { it > 5 }
    .map { it * 2 }
    .sum()

// ❌ 不好：创建多个中间列表
val result = numbers
    .filter { it > 5 }
    .map { it * 2 }
    .sum()

这段代码展示了使用 Sequence 优化大数据处理的方法。第一组代码使用 asSequence() 将列表转换为序列，然后链式调用 filter()、map() 和 sum()。Sequence 使用延迟计算，不会创建中间列表，只在调用 sum() 时才执行所有操作。第二组代码直接在列表上链式调用 filter() 和 map()，每个操作都会创建一个中间列表，然后再调用 sum()。对于大数据集，第一种方法性能更好，因为它避免了创建多个中间集合。Sequence 特别适合处理大数据、需要多个链式操作的场景。

常见问题

Q1: fold 和 reduce 有什么区别？

A:

  • fold：有初始值，可处理空集合
  • reduce：无初始值，不能处理空集合
val numbers = listOf(1, 2, 3)

val sum1 = numbers.fold(0) { acc, x -> acc + x }      // 6
val sum2 = numbers.reduce { acc, x -> acc + x }       // 6

val empty = emptyList<Int>()
val sum3 = empty.fold(0) { acc, x -> acc + x }        // 0
// val sum4 = empty.reduce { acc, x -> acc + x }      // 异常

这段代码对比了 fold() 和 reduce() 的区别。对于非空集合，两者的结果相同：fold() 和 reduce() 都返回 6。对于空集合，fold() 返回初始值 0，而 reduce() 会抛出异常。这是两者最重要的区别：fold() 有初始值参数，可以安全处理空集合；reduce() 没有初始值，使用第一个元素作为初始值，因此不能处理空集合。在实际应用中，如果需要处理可能为空的集合，应该使用 fold()；如果确保集合非空，可以使用 reduce()。

Q2: 如何统计满足条件的元素？

A: 使用 count 或 filter + sum

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

// 方式 1：使用 count
val evenCount = numbers.count { it % 2 == 0 }

// 方式 2：使用 filter + size
val evenCount2 = numbers.filter { it % 2 == 0 }.size

// 方式 3：使用 fold
val evenCount3 = numbers.fold(0) { acc, x -> if (x % 2 == 0) acc + 1 else acc }

这段代码展示了统计满足条件的元素的三种方法。方式 1 使用 count() 函数直接计数，这是最简洁高效的方法。方式 2 使用 filter() 过滤出满足条件的元素，然后获取大小，这种方法会创建一个中间集合，性能较差。方式 3 使用 fold() 进行自定义聚合，虽然可行但代码更复杂。在三种方法中，方式 1 是最佳选择，因为 count() 是为这个目的专门优化的，不需要创建中间集合。

Q3: 如何计算加权平均值？

A: 使用 fold 或 map + sum

data class Item(val value: Int, val weight: Int)

val items = listOf(
    Item(10, 2),
    Item(20, 3),
    Item(30, 5)
)

// 方式 1：使用 fold
val weightedSum = items.fold(0) { acc, item -> acc + item.value * item.weight }
val totalWeight = items.fold(0) { acc, item -> acc + item.weight }
val weightedAverage = weightedSum.toDouble() / totalWeight

// 方式 2：使用 map + sum
val weightedSum2 = items.map { it.value * it.weight }.sum()
val totalWeight2 = items.map { it.weight }.sum()
val weightedAverage2 = weightedSum2.toDouble() / totalWeight2

这段代码展示了如何计算加权平均值。定义一个 Item 数据类，包含值和权重两个属性。方式 1 使用 fold() 计算加权总和和总权重，然后相除得到加权平均值。方式 2 使用 map() 将每个项目转换为加权值，然后调用 sum() 计算总和，再计算总权重。两种方法都可行，但方式 1 更高效，因为它只遍历一次集合。方式 2 会创建两个中间列表。加权平均值的计算公式是：加权总和 / 总权重。这个例子展示了如何使用聚合操作处理复杂的数据统计场景。

Q4: 如何处理空集合的聚合？

A: 使用 orEmpty() 或 fold 的初始值

val list: List<Int>? = null

// 方式 1：使用 orEmpty()
val sum1 = list.orEmpty().sum()

// 方式 2：使用 fold
val sum2 = list?.fold(0) { acc, x -> acc + x } ?: 0

// 方式 3：使用 maxOrNull
val max = list?.maxOrNull() ?: 0

这段代码展示了如何处理空集合或 null 的聚合操作。方式 1 使用 orEmpty() 函数，如果列表为 null，则返回空列表，然后调用 sum() 返回 0。这是最简洁的方法。方式 2 使用 Elvis 操作符 ?. 进行安全调用，如果列表为 null 则返回 null，然后使用 Elvis 操作符 ?: 提供默认值 0。方式 3 使用 maxOrNull() 获取最大值，如果列表为 null 或为空，则返回 null，然后使用 Elvis 操作符提供默认值 0。在处理可能为 null 或为空的集合时，这些方法都很有用。orEmpty() 是最推荐的方法，因为它代码简洁且意图明确。

Q5: 聚合操作的时间复杂度是多少？

A: 大多数聚合操作的时间复杂度都是 O(n)，因为需要遍历所有元素

val numbers = listOf(1, 2, 3, 4, 5)

// 所有这些操作都是 O(n)
val sum = numbers.sum()              // O(n)
val max = numbers.maxOrNull()        // O(n)
val count = numbers.count { it > 2 } // O(n)
val product = numbers.fold(1) { a, x -> a * x }  // O(n)

这段代码展示了聚合操作的时间复杂度。所有列出的聚合操作都是 O(n) 复杂度，因为它们都需要遍历集合中的所有元素。sum() 遍历所有元素并累加。maxOrNull() 遍历所有元素找出最大值。count() 遍历所有元素并计数满足条件的元素。fold() 遍历所有元素执行聚合操作。虽然这些操作的时间复杂度都是 O(n)，但它们的常数因子不同。例如，sum() 的常数因子很小，而 count() 带条件判断的常数因子可能稍大。在选择聚合操作时，应该考虑这些因素。对于大数据集，使用 Sequence 可以避免创建中间集合，进一步提高性能。

总结

关键要点

  • ✅ sum、average、maxOrNull 等是最常用的聚合函数
  • ✅ fold 用于自定义聚合逻辑，reduce 用于简化聚合
  • ✅ 使用 count 进行条件计数
  • ✅ 避免重复遍历，一次遍历完成多个统计
  • ✅ 使用 Sequence 优化大数据处理性能

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net

# harmonyos # kotlin # android
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

Kimi/豆包/DeepSeek生成的论文怎么降AI率？不同AI工具降AIGC策略详解

avatar AtomGit开源社区
cover

定稿前必看！专科生专属的降AIGC平台 千笔·专业降AIGC智能体 VS WPS AI 用起来更顺手！

avatar AtomGit开源社区
cover

Polkadot Bulletin Chain 解析：用“临时存储“破解区块链状态膨胀困局

avatar AtomGit开源社区