Kotlin Flow常用用法

Kotlin Flow 是 Kotlin 编程语言中的一个强盛特性，用于处置惩罚异步数据流。它是 Kotlin 协程库的一部分，旨在以声明式和相应式的方式处置惩罚异步数据流。Flow 的筹划与协程无缝集成，使得异步编程更加简朴和直观。

1. suspend fun main() {
3.     // 创建Flow的几种方法
4.     val flow = flow {
5.         emit(1)
6.         emit(2)
7.         emit(3)
8.         emit(4)
9.         emit(5)
10.     }.collect {
11.         println(it) // 打印1 2 3 4 5 共5行
12.     }
14.     val flow2 = flowOf(1, 2, 3, 4, 5)
15.     flow2.collect {
16.         println(it) // 打印1 2 3 4 5 共5行
17.     }
19.     val flow3 = listOf(1, 2, 3).asFlow();
20.     flow3.collect {
21.         println(it) // 打印1 2 3 共3行
22.     }
24.     val flow4 = channelFlow {
25.         send(1)
26.         send(2)
27.         send(3)
28.         send(4)
29.         send(5)
31.     }
33.     flow4.collect {
34.         println(it) // 打印1 2 3 4 5 共5行
35.     }
36.     // 获取第一个和最后一个元素
37.     val firstValue = flow4.first()
38.     println(firstValue) // 打印1
39.     val lastValue = flow4.last()
40.     println(lastValue) // 打印5
41.     //3.Flow的操作符
42.     // 3.1 map 操作符 将Flow中的每个元素进行转换
43.     val flow5 = flowOf(1, 2, 3, 4, 5)
44.     flow5.map {
45.         it * 3  //无效
46.         it * 5  //无效
47.         it * 10//  有效以最后一行为准注意与trans的区别
48.     }.collect {
49.         println(it) // 打印10 20 30 40 50 共5行
50.     }
52.     // 3.2 trans 操作符 将Flow中的每个元素进行转换
53.     val flow6 = flowOf(1, 2, 3)
54.     flow6.transform {
55.         emit(it * 3)  //有效
56.         emit(it * 5)  //有效
57.     }.collect {
58.         println(it) // 打印3 5 6 10 9 15 共6行 注意与map的区别
59.     }
61.     // 3.3 filter 操作符 过滤Flow中符合条件的元素
62.     val flow7 = flowOf(1, 2, 3, 4, 5, 6)
63.     flow7.filter {
64.         it % 3 == 0
65.     }.collect {
66.         println(it) //打印 3 6 共2行
67.     }
68.     // take 操作符 取Flow中的前n个元素
69.     val flow8 = flowOf(1, 2, 3, 4, 5, 6)
70.     flow8.take(3).collect {
71.         println(it) //打印 1 2 3 共3行
72.     }
74.     //3.4 组合操作符 zip 将2个Flow的值按顺序组合
75.     val flow9 = flowOf(1, 2, 3)
76.     val flow10 = flowOf("a", "b", "c")
77.     flow9.zip(flow10) { it1, it2 ->
78.         "$it1$it2" //将两个Flow的值按顺序组合
79.     }.collect {
80.         println(it) //打印 1a 2b 3c 共3行
81.     }
82.     println("=================================")
83.     //3.5 组合操作符 combine 将多个 Flow 的最新值组合,有可能不是按顺序,比如：
84.     // 1a
85.     //2b
86.     //2c
87.     //3c
88.     //使用runBlocking运行
90.     runBlocking {
91.         val flow11 = flowOf(1, 2, 3)
92.         val flow12 = flowOf("a", "b", "c")
93.         flow11.combine(flow12) { it1, it2 ->
94.             "$it1$it2" //将两个Flow的值按顺序组合
95.         }.collect {
96.             println(it) //打印 1a 2b 3c 共3行
97.         }
98.     }
99.     //3.6 flatMapConcat 扁平化操作符 按顺序将每个值转换为 Flow 并连接
100.     val flow13 = flowOf(1, 2, 3)
101.     flow13.flatMapConcat { it -> flowOf(it, it * 2, it * 3) }.collect {
102.         println(it) //打印 1 2 3 2 4 6 3 6 9 共9行 与transform有点类似
103.     }
104.     //3.7 flatMapMerge 扁平化操作符 并发将每个值转换为 Flow 并连接
105.     val flow14 = flowOf(1, 2, 3)
106.     flow14.flatMapMerge { it -> flowOf(it, it * 2, it * 3) }.collect {
107.         println(it) //打印 1 2 3 2 4 6 3 6 9 或者  369246123共9行 与transform有点类似
108.     }
110.     //3.8 flatMapLatest 扁平化操作符 只处理最新的值，取消之前的转换
111.     val flow15 = flowOf(1, 2, 3)
112.     flow15.flatMapLatest { it -> flowOf(it, it * 2, it * 3) }.collect {
113.         println(it) // 打印 1 2 3 2 4 6 3 6 9
114.     }
115.     //3.9 flatMapLatest 扁平化操作符 只处理最新的值，取消之前的转换 ？
116.     val flow16 = flowOf(1, 2, 3)
117.     flow16.flatMapLatest { it -> flowOf(it, it * 2, it * 3) }.collect {
118.         println(it) //
119.     }
121.     // 4. Flow 的冷流与热流
122. //    4.1 冷流（Cold Stream）
123. //    Flow 是冷流，只有在被收集时才会执行。
124. //    每次收集都会重新执行 Flow 的代码。
125. //    示例：
126.     val flow17 = flow {
127.         println("Flow start...")
128.         emit(1)
129.         emit(2)
130.     }
131.     flow17.collect {
132.         println("Collect : $it") // Flow start...  Collect : 1  Collect : 2 共三行
135.     }
136.     flow17.collect {
137.         println("Collect : $it")  // Flow start...  Collect : 1  Collect : 2 共三行
138.     }
140.     // 4.2 热流（Hot Stream）
141. // Kotlin 中的 StateFlow  是热流的实现
142. //    热流是预先启动的，可以在收集之前就开始执行。
143. //    热流可以被多个收集者共享。
144. //    示例：
145.     val stateFlow = MutableStateFlow(0)
146.     stateFlow.value = 1
147.     stateFlow.value = 2
148.     stateFlow.value = 3
149.     stateFlow.collect {
150.         println("Collect : $it") // Collect : 3
151.     }
152. }

复制代码

//  模仿网络哀求

1. suspend fun main() {
2.     //  模拟网络请求
3.     fun requestNetwork(): Flow<Int> = flow {
4.         repeat(3) {
5.             delay(1000)
6.             emit(it)
7.         }
8.     }
9.         requestNetwork().collect { println(it) } //打印 0 1 2 共3行
11. }

复制代码

总结
Kotlin Flow 是一个强盛的工具，用于处置惩罚异步数据流。它的核心上风包罗：
冷流模子：按需实行，节省资源。
丰富的操纵符：支持复杂的数据流处置惩罚。
与协程无缝集成：简化异步编程。
通过 Flow，你可以以声明式的方式编写异步代码，同时享受 Kotlin 协程带来的简便性和高效性。假如你必要处置惩罚连续的数据流，Flow 是一个非常值得学习和利用的工具！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告