Android RxJava：詳解 條件 / 布爾操作符

原創 栀夏暖阳 2020-06-21 21:16

目錄

目錄

1. 作用

通過設置函數，判斷被觀察者（Observable）發送的事件是否符合條件

2. 類型

RxJava2中，條件 / 布爾操作符的類型包括：

示意圖

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

3. 具體操作符詳解

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

 

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

3.1 all（）

作用：判斷髮送的每項數據是否都滿足 設置的函數條件

若滿足，返回 true；否則，返回 false

  • 具體代碼

 


  Observable.just(1,2,3,4,5,6)
                .all(new Predicate<Integer>(){
                    @Override
                    public boolean test( Integer integer) throws Exception {
                        return (integer<=10);
                        // 該函數用於判斷Observable發送的10個數據是否都滿足integer<=10
                    }
                }).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.d(TAG,"result is "+ aBoolean);
                // 輸出返回結果
            }

        });

  • 測試結果：因爲所有數據都滿足函數內條件 （每項數據<=10）

     

    示意圖

3.2 takeWhile（）

作用：判斷髮送的每項數據是否滿足 設置函數條件

若發送的數據滿足該條件，則發送該項數據；否則不發送

  • 具體代碼

 

// 1. 每1s發送1個數據 = 從0開始，遞增1，即0、1、2、3
        Observable.interval(1, TimeUnit.SECONDS)
                // 2. 通過takeWhile傳入一個判斷條件
                .takeWhile(new Predicate<Long>(){
                    @Override
                    public boolean test( Long integer) throws Exception {
                        return (integer<3);
                        // 當發送的數據滿足<3時，才發送Observable的數據
                    }
                }).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) {
            }

            @Override
            public void onComplete() {
            }
        });
  • 測試結果

示意圖

3.3 skipWhile（）

作用：判斷髮送的每項數據是否滿足 設置函數條件

直到該判斷條件 = false時，纔開始發送Observable的數據

  • 具體使用

 

// 1. 每隔1s發送1個數據 = 從0開始，每次遞增1
        Observable.interval(1, TimeUnit.SECONDS)
                // 2. 通過skipWhile（）設置判斷條件
                .skipWhile(new Predicate<Long>(){
                    @Override
                    public boolean test( Long aLong) throws Exception {
                        return (aLong<5);
                        // 直到判斷條件不成立 = false = 發射的數據≥5，纔開始發送數據
                    }
                }).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) {
            }

            @Override
            public void onComplete() {
            }
        });
  • 測試結果

示意圖

3.4 takeUntil（）

作用：執行到某個條件時，停止發送事件。具體使用如下：

 

// 1. 每1s發送1個數據 = 從0開始，遞增1，即0、1、2、3
        Observable.interval(1, TimeUnit.SECONDS)
                // 2. 通過takeUntil的Predicate傳入判斷條件
                .takeUntil(new Predicate<Long>(){
                    @Override
                    public boolean test( Long integer) throws Exception {
                        return (integer>3);
                        // 返回true時，就停止發送事件
                        // 當發送的數據滿足>3時，就停止發送Observable的數據
                    }
                }).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) {
            }

            @Override
            public void onComplete() {
            }
        });
  • 測試結果

webpuploading.4e448015.gif轉存失敗重新上傳取消

示意圖

該判斷條件也可以是Observable，即 等到 takeUntil（） 傳入的Observable開始發送數據，（原始）第1個Observable的數據停止發送數據

 

// （原始）第1個Observable：每隔1s發送1個數據 = 從0開始，每次遞增1
        Observable.interval(1, TimeUnit.SECONDS)
                // 第2個Observable：延遲5s後開始發送1個Long型數據
                .takeUntil(Observable.timer(5, TimeUnit.SECONDS))
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "開始採用subscribe連接");
                    }

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

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

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

                });
  • 測試結果

當第 5s 時，第2個 Observable 開始發送數據，於是（原始）第1個 Observable 停止發送數據

示意圖

3.5 skipUntil（）

  • 作用：等到 skipUntil（） 傳入的Observable開始發送數據，（原始）第1個Observable的數據纔開始發送數據

  • 具體使用

 

                // （原始）第1個Observable：每隔1s發送1個數據 = 從0開始，每次遞增1
        Observable.interval(1, TimeUnit.SECONDS)
                // 第2個Observable：延遲5s後開始發送1個Long型數據
                .skipUntil(Observable.timer(5, TimeUnit.SECONDS))
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "開始採用subscribe連接");
                    }

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

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

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

                });
  • 測試結果：5s後（ skipUntil（） 傳入的Observable開始發送數據），（原始）第1個Observable的數據纔開始發送

示意圖

3.6 SequenceEqual（）

  • 作用：判定兩個Observables需要發送的數據是否相同

若相同，返回 true；否則，返回 false

  • 具體使用

 

Observable.sequenceEqual(
                Observable.just(4,5,6),
                Observable.just(4,5,6)
        )
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept( Boolean aBoolean) throws Exception {
                        Log.d(TAG,"2個Observable是否相同："+ aBoolean);
                        // 輸出返回結果
                    }
                });
  • 測試結果

示意圖

3.7 contains（）

  • 作用：判斷髮送的數據中是否包含指定數據
  1. 若包含，返回 true；否則，返回 false
  2. 內部實現 = exists（）
  • 具體代碼

 

Observable.just(1,2,3,4,5,6)
                .contains(4)
                .subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.d(TAG,"result is "+ aBoolean);
                // 輸出返回結果
            }

        });

  • 測試結果：因爲發送的數據中包含4

     

    示意圖

3.8 isEmpty（）

  • 作用：判斷髮送的數據是否爲空

若爲空，返回 true；否則，返回 false

  • 具體代碼

 

Observable.just(1,2,3,4,5,6)
          .isEmpty() // 判斷髮送的數據中是否爲空
        }).subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                Log.d(TAG,"result is "+ aBoolean); 
                // 輸出返回結果
            }
        });

  • 測試結果：因爲發送的數據不爲空

     

    示意圖

3.9 amb（）

  • 作用：當需要發送多個 Observable時，只發送 先發送數據的Observable的數據，而其餘 Observable則被丟棄。

  • 具體代碼

 

       // 設置2個需要發送的Observable & 放入到集合中
        List<ObservableSource<Integer>> list= new ArrayList <>();
        // 第1個Observable延遲1秒發射數據
        list.add( Observable.just(1,2,3).delay(1,TimeUnit.SECONDS));
        // 第2個Observable正常發送數據
        list.add( Observable.just(4,5,6));

        // 一共需要發送2個Observable的數據
        // 但由於使用了amba（）,所以僅發送先發送數據的Observable
        // 即第二個（因爲第1個延時了）
        Observable.amb(list).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "接收到了事件 "+integer);
            }
        });

  • 測試結果：即只發送了先發送數據的Observable的數據 = 4，5，6

     

    示意圖

3.10 defaultIfEmpty（）

  • 作用：在不發送任何有效事件（ Next事件）、僅發送了 Complete 事件的前提下，發送一個默認值

  • 具體使用

 

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                // 不發送任何有效事件
                //  e.onNext(1);
                //  e.onNext(2);

                // 僅發送Complete事件
                e.onComplete();
            }
        }).defaultIfEmpty(10) // 若僅發送了Complete事件，默認發送 值 = 10
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "開始採用subscribe連接");
                    }

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

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "對Complete事件作出響應");
                    }
                });
  • 測試結果

示意圖

至此，RxJava2中常用的條件 / 布爾操作符講解完畢

4. Demo地址

上述所有的Demo源代碼都存放在：Carson_Ho的Github地址：RxJava2_功能性操作符

5. 總結

  • 下面，我將用一張圖總結 RxJava2 中常用的條件 / 布爾操作符

示意圖



作者：Carson_Ho
鏈接：https://www.jianshu.com/p/954426f90325
來源：簡書
著作權歸作者所有。商業轉載請聯繫作者獲得授權，非商業轉載請註明出處。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Android RxJava 實際應用講解：網絡請求嵌套回調

栀夏暖阳 2020-03-17 00:46:25

Android RxJava 實際應用講解：網絡請求嵌套回調

栀夏暖阳 2020-03-17 00:46:25

Android RxJava： 這是一份全面的 操作符 使用匯總 （含詳細實例講解）

栀夏暖阳 2019-02-22 01:48:13