前言

Rxjava，由于其基于事件流的鏈式調(diào)用、邏輯簡潔 & 使用簡單的特點，深受各大 Android開發(fā)者的歡迎。

如果還不了解 RxJava，請看文章：Android：這是一篇清晰 & 易懂的Rxjava 入門教程

RxJava如此受歡迎的原因，在于其提供了豐富 & 功能強大的操作符，幾乎能完成所有的功能需求
今天，我將為大家詳細介紹RxJava操作符中最常用的 組合 / 合并操作符，并附帶 Retrofit 結(jié)合 RxJava的實例Demo教學(xué)，希望你們會喜歡。

Carson帶你學(xué)RxJava系列文章，包括 原理、操作符、應(yīng)用場景、背壓等等，請關(guān)注看文章：Android：這是一份全面 & 詳細的RxJava學(xué)習(xí)指南

1. 作用

組合多個被觀察者（Observable） & 合并需要發(fā)送的事件

2. 類型

RxJava 2 中，常見的組合 / 合并操作符主要有：

示意圖
下面，我將對每個操作符進行詳細講解

3. 應(yīng)用場景 & 對應(yīng)操作符介紹

注：在使用RxJava 2操作符前，記得在項目的Gradle中添加依賴：

dependencies {
      compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
      compile 'io.reactivex.rxjava2:rxjava:2.0.7'
      // 注：RxJava2 與 RxJava1 不能共存，即依賴不能同時存在
}

3.1 組合多個被觀察者

該類型的操作符的作用 = 組合多個被觀察者

concat（） / concatArray（）

作用
組合多個被觀察者一起發(fā)送數(shù)據(jù)，合并后 按發(fā)送順序串行執(zhí)行

二者區(qū)別：組合被觀察者的數(shù)量，即concat（）組合被觀察者數(shù)量≤4個，而concatArray（）則可＞4個

具體使用

// concat（）：組合多個被觀察者（≤4個）一起發(fā)送數(shù)據(jù)
        // 注：串行執(zhí)行
        Observable.concat(Observable.just(1, 2, 3),
                           Observable.just(4, 5, 6),
                           Observable.just(7, 8, 9),
                           Observable.just(10, 11, 12))
                  .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應(yīng)");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應(yīng)");
                    }
                });

// concatArray（）：組合多個被觀察者一起發(fā)送數(shù)據(jù)（可＞4個）
        // 注：串行執(zhí)行
        Observable.concatArray(Observable.just(1, 2, 3),
                           Observable.just(4, 5, 6),
                           Observable.just(7, 8, 9),
                           Observable.just(10, 11, 12),
                           Observable.just(13, 14, 15))
                  .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應(yīng)");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應(yīng)");
                    }
                });

測試結(jié)果

concat（）情況

concatArray（）情況

merge（） / mergeArray（）

作用
組合多個被觀察者一起發(fā)送數(shù)據(jù)，合并后 按時間線并行執(zhí)行

二者區(qū)別：組合被觀察者的數(shù)量，即merge（）組合被觀察者數(shù)量≤4個，而mergeArray（）則可＞4個

區(qū)別上述concat（）操作符：同樣是組合多個被觀察者一起發(fā)送數(shù)據(jù)，但concat（）操作符合并后是按發(fā)送順序串行執(zhí)行

具體使用

// merge（）：組合多個被觀察者（＜4個）一起發(fā)送數(shù)據(jù)
        // 注：合并后按照時間線并行執(zhí)行
        Observable.merge(
                Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS), // 從0開始發(fā)送、共發(fā)送3個數(shù)據(jù)、第1次事件延遲發(fā)送時間 = 1s、間隔時間 = 1s
                Observable.intervalRange(2, 3, 1, 1, TimeUnit.SECONDS)) // 從2開始發(fā)送、共發(fā)送3個數(shù)據(jù)、第1次事件延遲發(fā)送時間 = 1s、間隔時間 = 1s
                  .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應(yīng)");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應(yīng)");
                    }
                });

// mergeArray（） = 組合4個以上的被觀察者一起發(fā)送數(shù)據(jù)，此處不作過多演示，類似concatArray（）

測試結(jié)果

兩個被觀察者發(fā)送事件并行執(zhí)行，輸出結(jié)果 = 0,2 -> 1,3 -> 2,4

33333.gif

concatDelayError（） / mergeDelayError（）

作用

示意圖

具體使用

a. 無使用concatDelayError（）的情況

Observable.concat(
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);
                        emitter.onError(new NullPointerException()); // 發(fā)送Error事件，因為無使用concatDelayError，所以第2個Observable將不會發(fā)送事件
                        emitter.onComplete();
                    }
                }),
                Observable.just(4, 5, 6))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應(yīng)");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應(yīng)");
                    }
                });

測試結(jié)果：第1個被觀察者發(fā)送Error事件后，第2個被觀察者則不會繼續(xù)發(fā)送事件

示意圖


<-- 使用了concatDelayError（）的情況 -->
Observable.concatArrayDelayError(
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);
                        emitter.onError(new NullPointerException()); // 發(fā)送Error事件，因為使用了concatDelayError，所以第2個Observable將會發(fā)送事件，等發(fā)送完畢后，再發(fā)送錯誤事件
                        emitter.onComplete();
                    }
                }),
                Observable.just(4, 5, 6))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應(yīng)");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應(yīng)");
                    }
                });

測試結(jié)果：第1個被觀察者的Error事件將在第2個被觀察者發(fā)送完事件后再繼續(xù)發(fā)送

示意圖

mergeDelayError（）操作符同理，此處不作過多演示

3.2 合并多個事件

該類型的操作符主要是對多個被觀察者中的事件進行合并處理。

Zip（）

作用
合并多個被觀察者（Observable）發(fā)送的事件，生成一個新的事件序列（即組合過后的事件序列），并最終發(fā)送
原理
具體請看下圖

示意圖

特別注意：

事件組合方式 = 嚴格按照原先事件序列進行對位合并
最終合并的事件數(shù)量 = 多個被觀察者（Observable）中數(shù)量最少的數(shù)量

即如下圖

示意圖

具體使用

<-- 創(chuàng)建第1個被觀察者 -->
        Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "被觀察者1發(fā)送了事件1");
                emitter.onNext(1);
                // 為了方便展示效果，所以在發(fā)送事件后加入2s的延遲
                Thread.sleep(1000);

                Log.d(TAG, "被觀察者1發(fā)送了事件2");
                emitter.onNext(2);
                Thread.sleep(1000);

                Log.d(TAG, "被觀察者1發(fā)送了事件3");
                emitter.onNext(3);
                Thread.sleep(1000);

                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io()); // 設(shè)置被觀察者1在工作線程1中工作

<-- 創(chuàng)建第2個被觀察者 -->
        Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                Log.d(TAG, "被觀察者2發(fā)送了事件A");
                emitter.onNext("A");
                Thread.sleep(1000);

                Log.d(TAG, "被觀察者2發(fā)送了事件B");
                emitter.onNext("B");
                Thread.sleep(1000);

                Log.d(TAG, "被觀察者2發(fā)送了事件C");
                emitter.onNext("C");
                Thread.sleep(1000);

                Log.d(TAG, "被觀察者2發(fā)送了事件D");
                emitter.onNext("D");
                Thread.sleep(1000);

                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.newThread());// 設(shè)置被觀察者2在工作線程2中工作
        // 假設(shè)不作線程控制，則該兩個被觀察者會在同一個線程中工作，即發(fā)送事件存在先后順序，而不是同時發(fā)送

<-- 使用zip變換操作符進行事件合并 -->
// 注：創(chuàng)建BiFunction對象傳入的第3個參數(shù) = 合并后數(shù)據(jù)的數(shù)據(jù)類型
        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String string) throws Exception {
                return  integer + string;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
            }

            @Override
            public void onNext(String value) {
                Log.d(TAG, "最終接收到的事件 =  " + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        });

測試結(jié)果

示意圖

特別注意：
1. 盡管被觀察者2的事件D沒有事件與其合并，但還是會繼續(xù)發(fā)送
2. 若在被觀察者1 & 被觀察者2的事件序列最后發(fā)送onComplete()事件，則被觀察者2的事件D也不會發(fā)送，測試結(jié)果如下

示意圖

因為Zip（）操作符較為復(fù)雜 & 難理解，此處將用1張圖總結(jié)

示意圖

關(guān)于Zip（）結(jié)合RxJava 與Rxtrofit的實例講解將在第4節(jié)中詳細講解

combineLatest（）

作用
當(dāng)兩個Observables中的任何一個發(fā)送了數(shù)據(jù)后，將先發(fā)送了數(shù)據(jù)的Observables 的最新（最后）一個數(shù)據(jù) 與另外一個Observable發(fā)送的每個數(shù)據(jù)結(jié)合，最終基于該函數(shù)的結(jié)果發(fā)送數(shù)據(jù)

與Zip（）的區(qū)別：Zip（） = 按個數(shù)合并，即1對1合并；CombineLatest（） = 按時間合并，即在同一個時間點上合并

具體使用

Observable.combineLatest(
                    Observable.just(1L, 2L, 3L), // 第1個發(fā)送數(shù)據(jù)事件的Observable
                    Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS), // 第2個發(fā)送數(shù)據(jù)事件的Observable：從0開始發(fā)送、共發(fā)送3個數(shù)據(jù)、第1次事件延遲發(fā)送時間 = 1s、間隔時間 = 1s
                    new BiFunction<Long, Long, Long>() {
                @Override
                public Long apply(Long o1, Long o2) throws Exception {
                    // o1 = 第1個Observable發(fā)送的最新（最后）1個數(shù)據(jù)
                    // o2 = 第2個Observable發(fā)送的每1個數(shù)據(jù)
                    Log.e(TAG, "合并的數(shù)據(jù)是： "+ o1 + " "+ o2);
                    return o1 + o2;
                    // 合并的邏輯 = 相加
                    // 即第1個Observable發(fā)送的最后1個數(shù)據(jù) 與 第2個Observable發(fā)送的每1個數(shù)據(jù)進行相加
                }
            }).subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long s) throws Exception {
                    Log.e(TAG, "合并的結(jié)果是： "+s);
                }
            });

測試結(jié)果

示意圖

combineLatestDelayError（）

作用類似于concatDelayError（） / mergeDelayError（） ，即錯誤處理，此處不作過多描述

reduce（）

作用
把被觀察者需要發(fā)送的事件聚合成1個事件 & 發(fā)送

聚合的邏輯根據(jù)需求撰寫，但本質(zhì)都是前2個數(shù)據(jù)聚合，然后與后1個數(shù)據(jù)繼續(xù)進行聚合，依次類推

具體使用

Observable.just(1,2,3,4)
                .reduce(new BiFunction<Integer, Integer, Integer>() {
                    // 在該復(fù)寫方法中復(fù)寫聚合的邏輯
                    @Override
                    public Integer apply(@NonNull Integer s1, @NonNull Integer s2) throws Exception {
                        Log.e(TAG, "本次計算的數(shù)據(jù)是： "+s1 +" 乘 "+ s2);
                        return s1 * s2;
                        // 本次聚合的邏輯是：全部數(shù)據(jù)相乘起來
                        // 原理：第1次取前2個數(shù)據(jù)相乘，之后每次獲取到的數(shù)據(jù) = 返回的數(shù)據(jù)x原始下1個數(shù)據(jù)每
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer s) throws Exception {
                Log.e(TAG, "最終計算的結(jié)果是： "+s);

            }
        });

測試結(jié)果

示意圖

collect（）

作用
將被觀察者Observable發(fā)送的數(shù)據(jù)事件收集到一個數(shù)據(jù)結(jié)構(gòu)里
具體使用

Observable.just(1, 2, 3 ,4, 5, 6)
                .collect(
                        // 1. 創(chuàng)建數(shù)據(jù)結(jié)構(gòu)（容器），用于收集被觀察者發(fā)送的數(shù)據(jù)
                        new Callable<ArrayList<Integer>>() {
                            @Override
                            public ArrayList<Integer> call() throws Exception {
                                return new ArrayList<>();
                            }
                            // 2. 對發(fā)送的數(shù)據(jù)進行收集
                        }, new BiConsumer<ArrayList<Integer>, Integer>() {
                            @Override
                            public void accept(ArrayList<Integer> list, Integer integer)
                                    throws Exception {
                                // 參數(shù)說明：list = 容器，integer = 后者數(shù)據(jù)
                                list.add(integer);
                                // 對發(fā)送的數(shù)據(jù)進行收集
                            }
                        }).subscribe(new Consumer<ArrayList<Integer>>() {
            @Override
            public void accept(@NonNull ArrayList<Integer> s) throws Exception {
                Log.e(TAG, "本次發(fā)送的數(shù)據(jù)是： "+s);

            }
        });

測試結(jié)果

示意圖

3.3 發(fā)送事件前追加發(fā)送事件

startWith（） / startWithArray（）

作用
在一個被觀察者發(fā)送事件前，追加發(fā)送一些數(shù)據(jù) / 一個新的被觀察者
具體使用

<-- 在一個被觀察者發(fā)送事件前，追加發(fā)送一些數(shù)據(jù) -->
        // 注：追加數(shù)據(jù)順序 = 后調(diào)用先追加
        Observable.just(4, 5, 6)
                  .startWith(0)  // 追加單個數(shù)據(jù) = startWith()
                  .startWithArray(1, 2, 3) // 追加多個數(shù)據(jù) = startWithArray()
                  .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應(yīng)");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應(yīng)");
                    }
                });


<-- 在一個被觀察者發(fā)送事件前，追加發(fā)送被觀察者 & 發(fā)送數(shù)據(jù) -->
        // 注：追加數(shù)據(jù)順序 = 后調(diào)用先追加
        Observable.just(4, 5, 6)
                .startWith(Observable.just(1, 2, 3))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "對Error事件作出響應(yīng)");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應(yīng)");
                    }
                });

測試結(jié)果

示意圖

3.4 統(tǒng)計發(fā)送事件數(shù)量

count（）

作用
統(tǒng)計被觀察者發(fā)送事件的數(shù)量
具體使用

// 注：返回結(jié)果 = Long類型
        Observable.just(1, 2, 3, 4)
                  .count()
                  .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG, "發(fā)送的事件數(shù)量 =  "+aLong);

                    }
                });

測試結(jié)果

示意圖

至此，RxJava 2中的組合 / 合并操作符講解完畢。

4. 實際開發(fā)需求案例

下面，我將講解組合 / 合并操作符的常見實際需求：

從緩存（磁盤、內(nèi)存）中獲取緩存數(shù)據(jù)
合并數(shù)據(jù)源
聯(lián)合判斷

下面，我將對每個應(yīng)用場景進行實例Demo演示講解。

4.1 獲取緩存數(shù)據(jù)

即從緩存中（磁盤緩存 & 內(nèi)存緩存）獲取數(shù)據(jù)；若緩存中無數(shù)據(jù)，才通過網(wǎng)絡(luò)請求獲取數(shù)據(jù)
具體請看文章：Android RxJava 實際應(yīng)用講解：從磁盤 / 內(nèi)存緩存中獲取緩存數(shù)據(jù)

4.2 合并數(shù)據(jù)源 & 同時展示

即，數(shù)據(jù)源來自不同地方（如網(wǎng)絡(luò) + 本地），需要從不同的地方獲取數(shù)據(jù) & 同時展示
具體請看文章：Android RxJava 實際應(yīng)用講解：合并數(shù)據(jù)源

4.3 聯(lián)合判斷

即，同時對多個事件進行聯(lián)合判斷

如，填寫表單時，需要表單里所有信息（姓名、年齡、職業(yè)等）都被填寫后，才允許點擊 "提交" 按鈕

具體請看文章：Android RxJava 實際應(yīng)用講解：聯(lián)合判斷

5. Demo地址

上述所有的Demo源代碼都存放在：Carson_Ho的Github地址：RxJava2_組合 / 合并操作符

6. 總結(jié)

下面，我將用一張圖總結(jié) RxJava2 中常用的組合 / 合并操作符

示意圖

Carson帶你學(xué)RxJava系列文章：

入門
Carson帶你學(xué)Android：這是一篇清晰易懂的Rxjava入門教程
 Carson帶你學(xué)Android：面向初學(xué)者的RxJava使用指南
 Carson帶你學(xué)Android：RxJava2.0到底更新了什么？
原理
Carson帶你學(xué)Android：圖文解析RxJava原理
 Carson帶你學(xué)Android：手把手帶你源碼分析RxJava
使用教程：操作符
Carson帶你學(xué)Android：RxJava操作符教程
 Carson帶你學(xué)Android：RxJava創(chuàng)建操作符
 Carson帶你學(xué)Android：RxJava功能性操作符
 Carson帶你學(xué)Android：RxJava過濾操作符
 Carson帶你學(xué)Android：RxJava組合/合并操作符
 Carson帶你學(xué)Android：RxJava變換操作符
 Carson帶你學(xué)Android：RxJava條件/布爾操作符
實戰(zhàn)
Carson帶你學(xué)Android：什么時候應(yīng)該使用Rxjava？(開發(fā)場景匯總)
Carson帶你學(xué)Android：RxJava線程控制(含實例講解)
Carson帶你學(xué)Android：圖文詳解RxJava背壓策略
 Carson帶你學(xué)Android：RxJava、Retrofit聯(lián)合使用匯總(含實例教程)
Carson帶你學(xué)Android：優(yōu)雅實現(xiàn)網(wǎng)絡(luò)請求嵌套回調(diào)
Carson帶你學(xué)Android：網(wǎng)絡(luò)請求輪詢(有條件)
Carson帶你學(xué)Android：網(wǎng)絡(luò)請求輪詢(無條件)
Carson帶你學(xué)Android：網(wǎng)絡(luò)請求出錯重連(結(jié)合Retrofit)
Carson帶你學(xué)Android：合并數(shù)據(jù)源
 Carson帶你學(xué)Android：聯(lián)想搜索優(yōu)化
 Carson帶你學(xué)Android：功能防抖
 Carson帶你學(xué)Android：從磁盤/內(nèi)存緩存中獲取緩存數(shù)據(jù)
Carson帶你學(xué)Android：聯(lián)合判斷

歡迎關(guān)注Carson_Ho的簡書

不定期分享關(guān)于安卓開發(fā)的干貨，追求短、平、快，但卻不缺深度。

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

Carson帶你學(xué)Android：RxJava組合/合并操作符

Carson帶你學(xué)Android：RxJava組合/合并操作符

前言

目錄

1. 作用

2. 類型

3. 應(yīng)用場景 & 對應(yīng)操作符介紹

3.1 組合多個被觀察者

concat（） / concatArray（）

merge（） / mergeArray（）

concatDelayError（） / mergeDelayError（）

3.2 合并多個事件

Zip（）

combineLatest（）

combineLatestDelayError（）

reduce（）

collect（）

3.3 發(fā)送事件前追加發(fā)送事件

startWith（） / startWithArray（）

3.4 統(tǒng)計發(fā)送事件數(shù)量

count（）

4. 實際開發(fā)需求案例

4.1 獲取緩存數(shù)據(jù)

4.2 合并數(shù)據(jù)源 & 同時展示

4.3 聯(lián)合判斷

5. Demo地址

6. 總結(jié)

歡迎關(guān)注Carson_Ho的簡書

請點贊！因為你的鼓勵是我寫作的最大動力！

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Carson帶你學(xué)Android：RxJava組合/合并操作符

前言

目錄

1. 作用

2. 類型

3. 應(yīng)用場景 & 對應(yīng)操作符 介紹

3.1 組合多個被觀察者

concat（） / concatArray（）

merge（） / mergeArray（）

concatDelayError（） / mergeDelayError（）

3.2 合并多個事件

Zip（）

combineLatest（）

combineLatestDelayError（）

reduce（）

collect（）

3.3 發(fā)送事件前追加發(fā)送事件

startWith（） / startWithArray（）

3.4 統(tǒng)計發(fā)送事件數(shù)量

count（）

4. 實際開發(fā)需求案例

4.1 獲取緩存數(shù)據(jù)

4.2 合并數(shù)據(jù)源 & 同時展示

4.3 聯(lián)合判斷

5. Demo地址

6. 總結(jié)

歡迎關(guān)注Carson_Ho的簡書

請點贊！因為你的鼓勵是我寫作的最大動力！

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

3. 應(yīng)用場景 & 對應(yīng)操作符介紹

請點贊！因為你的鼓勵是我寫作的最大動力！