Rxjava2 Observable的布尔操作符详解及实例

Posted 2020-11-25 jiangming-blogs

目录

• 简要：
• 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（码云）