Android经典实战之Kotlin常用的 Flow 操作符

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

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

转换操作符

1、 map:

• 对流中的每个元素应用一个给定的变换函数。

  flowOf(1, 2, 3).map { it * 2 } // Produces 2, 4, 6
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

2、 filter:

• 过滤流中的元素，仅保留满足特定条件的元素。

  flowOf(1, 2, 3).filter { it % 2 == 0 } // Produces 2
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

3、 transform:

• 更强大的转换操作符，允许发射多个元素或不发射元素。

  flowOf(1, 2, 3).transform { emit(it * 2); emit(it + 1) } // Produces 2, 2, 4, 3, 6, 4
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

4、 scan:

• 类似于 fold，但会在流中发射每个中间累积值。

  flowOf(1, 2, 3).scan(0) { acc, value -> acc + value } // Produces 0, 1, 3, 6
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

过滤操作符

1、 filterNot:

• 过滤流中的元素，仅保留不满足特定条件的元素。

  flowOf(1, 2, 3).filterNot { it % 2 == 0 } // Produces 1, 3
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

2、 take:

• 只发射前 n 个元素。

  flowOf(1, 2, 3).take(2) // Produces 1, 2
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

3、 drop:

• 丢弃前 n 个元素，仅发射剩余的元素。

  flowOf(1, 2, 3).drop(2) // Produces 3
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

聚合操作符

1、 reduce:

• 将流中的元素两两结合成一个值，只发射最终的累积值。

  flowOf(1, 2, 3).reduce { acc, value -> acc + value } // Produces 6
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

2、 fold:

• 与 reduce 类似，但需要一个初始值。

  flowOf(1, 2, 3).fold(10) { acc, value -> acc + value } // Produces 16
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

扁平化操作符

1、 flatMapConcat:

• 将流的每个元素转换为流，然后按顺序连接这些流。

  flowOf(1, 2).flatMapConcat { flowOf(it, it + 1) } // Produces 1, 2, 2, 3
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

2、 flatMapMerge:

• 将流的每个元素转换为流，然后并发收集这些流。

  flowOf(1, 2).flatMapMerge { flowOf(it, it + 1) } // Produces 1, 2, 2, 3 (Order may vary)
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

3、 flatMapLatest:

• 将流的每个元素转换为流，但只收集最新生成的流。

  flowOf(1, 2).flatMapLatest { flowOf(it, it + 1) } // Produces 2, 3 (Flattens the last emitted item only)
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

错误处理操作符

1、 catch:

• 捕获流中发生的异常，并发射替代值或执行其他操作。

  flow {
    emit(1)
    throw RuntimeException("Error")
  }.catch { e -> emit(-1) } // Produces 1, -1
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

2、 retry:

• 在某个条件满足时重试流的收集。

  flow {
    emit(1)
    throw RuntimeException("Error")
  }.retry(3) // Tries to retry 3 times on error
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

终止操作符

1、 collect:

• 终止流的操作符，启动流的收集，并处理每个发射的元素。

  flowOf(1, 2, 3).collect { println(it) } // Prints 1, 2, 3
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

2、 first:

• 仅收集第一个元素的值。

  val firstElement = flowOf(1, 2, 3).first() // 1
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

3、 toList:

• 将流的元素收集到一个列表中。

  val list = flowOf(1, 2, 3).toList() // [1, 2, 3]
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

缓存操作符

1、 buffer:

• 使用缓冲区对流中的发射和收集进行解耦。

  flow {
    emit(1)
    emit(2)
  }.buffer().collect { println(it) } // Prints 1, 2
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

2、 conflate:

• 仅保留最后一个未处理的值，提高处理的效率。

  flow {
    emit(1)
    emit(2)
    emit(3)
  }.conflate().collect { println(it) } // Prints 3
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

3、 collectLatest:

• 当新值产生时，取消前一个值的收集。

  flow {
    emit(1)
    delay(100)
    emit(2)
  }.collectLatest { value ->
    delay(50)
    println(value)
  } // Only the latest emitted item will be printed
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

延迟和时间相关操作符

1、 debounce:

• 如果在指定的时间间隔内没有新元素发射时，才发射该元素。

  flow {
    emit(1)
    delay(100)
    emit(2)
    delay(100)
    emit(3)
  }.debounce(150) // Only emits 3
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

2、 timeout:

• 在指定的时间间隔内没有值被发射时抛出超时异常。

  flowOf(1, 2, 3).timeout(100) // Throws TimeoutCancellationException
  
          
  
            
          
          
          
  
            
  
            AI 代码解读
          
        
        

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

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