Rxjava2 Observable的布爾操做符詳解及實例

目錄

• 簡要：
• 1. All
• 2. Contains
• 3. IsEmpty
• 4. SequenceEqual
• 小結

簡要：

需求瞭解：

在 Rxjava 的衆多操做符中，有數據變換、過濾等，可是有的時候是否是有一些判斷的操做呢？好比判斷一個 Observable 的全部數據是否知足一個指定的條件，判斷某個 Observable 是否會發射一個指定的值等等的判斷操做，答案是確定的，Rxjava 中提供了一系列的布爾條件判斷操做符。

Rxjava中的布爾操做符主要包括：

• All：判斷是否全部的數據項都知足某個條件。
• Contains：判斷 Observable 是否會發射一個指定的值。
• IsEmpty：判斷原始Observable是否未發射任何數據。
• SequenceEqual：判斷兩個 Observables 發射的序列是否相等。

1. All

判斷是否全部的數據項都知足某個條件。

解析： 傳遞一個謂詞函數（predicate）給 All 操做符，這個函數接受原始 Observable 發射的數據，根據計算返回一個布爾值。 All 返回一個只發射一個單個布爾值的 Observable，若是原始 Observable 正常終止而且每一項數據都知足條件，就返回 true；若是原始 Observable 的任何一項數據不知足條件就返回 false。

示例代碼：

/**
         *  all(Predicate predicate)
         *  經過傳入的謂語函數predicate進行判斷全部數據項是否知足條件，而後返回一個判斷結果發射給觀察者
         */
        Observable.just(1, 2, 3, 4, 5)
                .all(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 5; // 判斷原始數據項中的全部數據項是否大於5
                    }
                })
                .subscribe(new SingleObserver<Boolean>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        System.out.println("--> onSubscribe");
                    }

                    @Override
                    public void onSuccess(Boolean aBoolean) {
                        System.out.println("--> onSuccess: " + aBoolean);
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("--> onError: " + e);
                    }
                });

輸出：

--> onSubscribe
--> onSuccess: false

Javadoc: all(Predicate predicate)

2. Contains

判斷 Observable 是否會發射一個指定的值。

解析： 給 Contains 傳一個指定的值，若是原始 Observable 發射了那個值，它返回的 Observable 將發射 true ，不然發射 false。

示例代碼：

/**
     *  contains(Object element)
     *  判斷原始Observable是否發射了指定的element數據
     */
    Observable.just(1, 2, 3, 4, 5)
            .contains(5)    // 判斷原始數據項中是否有數據項5
            .subscribe(new SingleObserver<Boolean>() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("--> onSubscribe");
                }

                @Override
                public void onSuccess(Boolean aBoolean) {
                    System.out.println("--> onSuccess: " + aBoolean);
                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("--> onError: " + e);
                }
            });

輸出：

--> onSubscribe
--> onSuccess: true

Javadoc: contains(Object element)

3. IsEmpty

判斷原始Observable是否未發射任何數據。

解析： 判斷原始 Observable 是否發射了數據項，若是原始 Observable 發射了數據，將發射 false，不然發射 true。

示例代碼：

/**
     *  isEmpty()
     *  判斷原始Observable是否發射了數據項，若是原始Observable發射了數據，將發射false，不然發射true。
     */
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onComplete();       // 不發射任何數據，直接發射完成通知
        }
    }).isEmpty()
      .subscribe(new SingleObserver<Boolean>() {
          @Override
          public void onSubscribe(Disposable d) {
              System.out.println("--> onSubscribe");
          }

          @Override
          public void onSuccess(Boolean aBoolean) {
              System.out.println("--> onSuccess: " + aBoolean);
          }

          @Override
          public void onError(Throwable e) {
              System.out.println("--> onError: " + e);
          }
      });

輸出：

--> onSubscribe
--> onSuccess: true

Javadoc: isEmpty()

4. SequenceEqual

判斷兩個 Observables 發射的序列是否相等。

解析： 傳遞兩個 Observable 給 SequenceEqual 操做符，它會比較兩個 Observable 的發射物，若是兩個序列是相同的（相同的數據，相同的順序，相同的終止狀態），它就發射 true，不然發射 false。還能夠能夠傳遞一個函數用於比較兩個數據項是否相同或者設置一個緩存大小指定第一個和第二個源 ObservableSource 預取的項數。

示例代碼：

// 建立Observable
    Observable<Integer> observable1 = Observable.range(1, 10);
    Observable<Integer> observable2 = Observable.range(1, 10);

    /**
     *  1. sequenceEqual(ObservableSource source1, ObservableSource source2)
     *  比較兩個Observable的數據項是否徹底相同（相同數據，順序，相同終止狀態），相同則發射true，不然發射false
     */
    Observable.sequenceEqual(observable1, observable2)
            .subscribe(new SingleObserver<Boolean>() {
                @Override
                public void onSubscribe(Disposable d) {
                    System.out.println("--> onSubscribe(1)");
                }

                @Override
                public void onSuccess(Boolean aBoolean) {
                    System.out.println("--> onSuccess(1): " + aBoolean);
                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("--> onError(1): " + e);
                }
            });

    System.out.println("----------------------------------------");
    /**
     *  2. sequenceEqual(ObservableSource source1, ObservableSource source2, BiPredicate isEqual, int bufferSize)
     *  isEqual:             // 可選參數，定義兩個Observable的數據項比較規則
     *  bufferSize：         //  從第一個和第二個源ObservableSource預取的項數
     *  經過指定的比較函數isEqual比較兩個Observable的數據項是否徹底相同（相同數據，順序，相同終止狀態），
     *  相同則發射true，不然發射false。還能夠經過bufferSize指定一個緩存大小。
     */
    Observable.sequenceEqual(observable1, observable2, new BiPredicate<Integer, Integer>() {
        @Override
        public boolean test(Integer t1, Integer t2) throws Exception {
            System.out.println("--> test(2): t1 = " + t1 + ", t2 = " + t2);
            return t1 == t2;    // 比較兩個Observable的數據序列數據是否相等
        }
    }, 3).subscribe(new SingleObserver<Boolean>() {
        @Override
        public void onSubscribe(Disposable d) {
            System.out.println("--> onSubscribe(2)");
        }

        @Override
        public void onSuccess(Boolean aBoolean) {
            System.out.println("--> onSuccess(2): " + aBoolean);
        }

        @Override
        public void onError(Throwable e) {
            System.out.println("--> onError(2): " + e);
        }
    });

輸出：

--> onSubscribe(1)
--> onSuccess(1): true
----------------------------------------
--> onSubscribe(2)
--> test(2): t1 = 1, t2 = 1
--> test(2): t1 = 2, t2 = 2
--> test(2): t1 = 3, t2 = 3
--> test(2): t1 = 4, t2 = 4
--> test(2): t1 = 5, t2 = 5
--> test(2): t1 = 6, t2 = 6
--> test(2): t1 = 7, t2 = 7
--> test(2): t1 = 8, t2 = 8
--> test(2): t1 = 9, t2 = 9
--> test(2): t1 = 10, t2 = 10
--> onSuccess(2): true

Javadoc: sequenceEqual(ObservableSource source1, ObservableSource source2)
Javadoc: sequenceEqual(ObservableSource source1, ObservableSource source2, BiPredicate isEqual)
Javadoc: sequenceEqual(ObservableSource source1, ObservableSource source2, int bufferSize)
Javadoc: sequenceEqual(ObservableSource source1, ObservableSource source2, BiPredicate isEqual, int bufferSize)

小結

本節主要介紹了Rxjava布爾（判斷）操做符能夠根據不一樣的條件返回 boolean 類型的值，對 Observable 進行不一樣的判斷。

提示：以上使用的Rxjava2版本: 2.2.12

Rx介紹與講解及完整目錄參考：Rxjava2 介紹與詳解實例

實例代碼：

• 代碼下載
  
• Github
  
• Gitee（碼雲）