Carson帶你學Android：RxJava組合/合并操作符

前言

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

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

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

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

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（）操作符較為復雜 & 難理解，此處將用1張圖總結(jié)

示意圖

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

combineLatest（）

作用
當兩個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>() {
                    // 在該復寫方法中復寫聚合的邏輯
                    @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帶你學RxJava系列文章：

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

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

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

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

最后編輯于：2021.09.17 22:12:58

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現(xiàn)的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
沈念sama閱讀 228,505評論 6贊 533
死咒
序言：濱河連續(xù)發(fā)生了三起死亡事件，死亡現(xiàn)場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發(fā)現(xiàn)死者居然都...
沈念sama閱讀 98,556評論 3贊 418
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
開封第一講書人閱讀 176,463評論 0贊 376
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長。經(jīng)常有香客問我，道長，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 63,009評論 1贊 312
?港島之戀（遺憾婚禮）
正文為了忘掉前任，我火速辦了婚禮，結(jié)果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
茶點故事閱讀 71,778評論 6贊 410
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布。她就那樣靜靜地躺著，像睡著了一般。火紅的嫁衣襯著肌膚如雪。梳的紋絲不亂的頭發(fā)上，一...
開封第一講書人閱讀 55,218評論 1贊 324
城市分裂傳說
那天，我揣著相機與錄音，去河邊找鬼。笑死，一個胖子當著我的面吹牛，可吹牛的內(nèi)容都是我干的。我是一名探鬼主播，決...
沈念sama閱讀 43,281評論 3贊 441
雙鴛鴦連環(huán)套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側(cè)響起，我...
開封第一講書人閱讀 42,436評論 0贊 288
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體，經(jīng)...
沈念sama閱讀 48,969評論 1贊 335
?護林員之死
正文獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內(nèi)容為張勛視角年9月15日...
茶點故事閱讀 40,795評論 3贊 354
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發(fā)現(xiàn)自己被綠了。大學時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片。...
茶點故事閱讀 42,993評論 1贊 369
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內(nèi)的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
沈念sama閱讀 38,537評論 5贊 359
?日本核電站爆炸內(nèi)幕
正文年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質(zhì)發(fā)生泄漏。R本人自食惡果不足惜，卻給世界環(huán)境...
茶點故事閱讀 44,229評論 3贊 347
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
開封第一講書人閱讀 34,659評論 0贊 26
一樁弒父案，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監(jiān)牢的瞬間，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 35,917評論 1贊 286
情欲美人皮
我被黑心中介騙來泰國打工，沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。一個月前我還...
沈念sama閱讀 51,687評論 3贊 392
代替公主和親
正文我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
茶點故事閱讀 47,990評論 2贊 374

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Carson帶你學Android：RxJava組合/合并操作符

Carson帶你學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的簡書

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

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Carson帶你學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的簡書

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

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

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