本文首发于公众号“AntDream”，欢迎微信搜索“AntDream”或扫描文章底部二维码关注，和我一起每天进步一点点

Kotlin 的 Flow 提供了一系列操作符，这些操作符类似于 RxJava，但更加简洁和易于使用。以下是一些常用的 Flow 操作符，分为不同类别：

转换操作符

1、 map:

  • 对流中的每个元素应用一个给定的变换函数。
flowOf(1, 2, 3).map { it * 2 } // Produces 2, 4, 6

2、 filter:

  • 过滤流中的元素，仅保留满足特定条件的元素。
flowOf(1, 2, 3).filter { it % 2 == 0 } // Produces 2

3、 transform:

  • 更强大的转换操作符，允许发射多个元素或不发射元素。
flowOf(1, 2, 3).transform { emit(it * 2); emit(it + 1) } // Produces 2, 2, 4, 3, 6, 4

4、 scan:

  • 类似于 fold，但会在流中发射每个中间累积值。
flowOf(1, 2, 3).scan(0) { acc, value -> acc + value } // Produces 0, 1, 3, 6

过滤操作符

1、 filterNot:

  • 过滤流中的元素，仅保留不满足特定条件的元素。
flowOf(1, 2, 3).filterNot { it % 2 == 0 } // Produces 1, 3

2、 take:

  • 只发射前 n 个元素。
flowOf(1, 2, 3).take(2) // Produces 1, 2

3、 drop:

  • 丢弃前 n 个元素，仅发射剩余的元素。
flowOf(1, 2, 3).drop(2) // Produces 3

聚合操作符

1、 reduce:

  • 将流中的元素两两结合成一个值，只发射最终的累积值。
flowOf(1, 2, 3).reduce { acc, value -> acc + value } // Produces 6

2、 fold:

  • 与 reduce 类似，但需要一个初始值。
flowOf(1, 2, 3).fold(10) { acc, value -> acc + value } // Produces 16

扁平化操作符

1、 flatMapConcat:

  • 将流的每个元素转换为流，然后按顺序连接这些流。
flowOf(1, 2).flatMapConcat { flowOf(it, it + 1) } // Produces 1, 2, 2, 3

2、 flatMapMerge:

  • 将流的每个元素转换为流，然后并发收集这些流。
flowOf(1, 2).flatMapMerge { flowOf(it, it + 1) } // Produces 1, 2, 2, 3 (Order may vary)

3、 flatMapLatest:

  • 将流的每个元素转换为流，但只收集最新生成的流。
flowOf(1, 2).flatMapLatest { flowOf(it, it + 1) } // Produces 2, 3 (Flattens the last emitted item only)

错误处理操作符

1、 catch:

  • 捕获流中发生的异常，并发射替代值或执行其他操作。
flow {
    emit(1)
    throw RuntimeException("Error")
}.catch { e -> emit(-1) } // Produces 1, -1

2、 retry:

  • 在某个条件满足时重试流的收集。
flow {
    emit(1)
    throw RuntimeException("Error")
}.retry(3) // Tries to retry 3 times on error

终止操作符

1、 collect:

  • 终止流的操作符，启动流的收集，并处理每个发射的元素。
flowOf(1, 2, 3).collect { println(it) } // Prints 1, 2, 3

2、 first:

  • 仅收集第一个元素的值。
val firstElement = flowOf(1, 2, 3).first() // 1

3、 toList:

  • 将流的元素收集到一个列表中。
val list = flowOf(1, 2, 3).toList() // [1, 2, 3]

缓存操作符

1、 buffer:

  • 使用缓冲区对流中的发射和收集进行解耦。
flow {
    emit(1)
    emit(2)
}.buffer().collect { println(it) } // Prints 1, 2

2、 conflate:

  • 仅保留最后一个未处理的值，提高处理的效率。
flow {
    emit(1)
    emit(2)
    emit(3)
}.conflate().collect { println(it) } // Prints 3

3、 collectLatest:

  • 当新值产生时，取消前一个值的收集。
flow {
    emit(1)
    delay(100)
    emit(2)
}.collectLatest { value ->
    delay(50)
    println(value)
} // Only the latest emitted item will be printed

延迟和时间相关操作符

1、 debounce:

  • 如果在指定的时间间隔内没有新元素发射时，才发射该元素。
flow {
    emit(1)
    delay(100)
    emit(2)
    delay(100)
    emit(3)
}.debounce(150) // Only emits 3

2、 timeout:

  • 在指定的时间间隔内没有值被发射时抛出超时异常。
flowOf(1, 2, 3).timeout(100) // Throws TimeoutCancellationException

这些操作符使得 Kotlin Flow 成为一个强大且灵活的数据流处理工具，能够处理各种应用场景中的异步数据流。通过合理使用这些操作符，你可以构建出高效且可维护的流数据处理逻辑。

欢迎关注我的公众号AntDream查看更多精彩文章！