Detailed examples of Boolean operators and the Rxjava2 Observable

table of Contents

brief:
1. All
2. Contains
3. IsEmpty
4. SequenceEqual
summary

brief:

You need to know:

In Rxjava many operators, there are data conversion, filtering, but sometimes is not some judge of operation it? For example, a judge Observable all the data meets a specified condition, to determine whether a Observable will launch a specified value, and so the judgment operation, the answer is yes, Rxjava provided a series of Boolean conditional operators .

RxjavaBoolean operators include:

All: Determining whether all items meet certain conditions.
Contains: Observable emits determining whether a specified value.
IsEmpty: Observable determining whether any of the original data is not transmitted.
SequenceEqual: Analyzing two Observables transmitted sequence are equal.

1. All

All items to determine whether certain conditions are met.

img-All

Analysis: passing a predicate function ( predicate) to the Alloperator, this function takes the raw data transmitted Observable, returns a Boolean value based on the calculation. All transmit only returns a Boolean value of a single Observable, if the original normal termination Observable and each data satisfy the condition , return true; if the original Observable of any one of the data does not satisfy the condition returns false.

Sample code:

        /**
         *  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);
                    }
                });

Output:

--> onSubscribe
--> onSuccess: false

Javadoc: all(Predicate predicate)

2. Contains

Observable emits determining whether a specified value.

img-Contains

解析： 给 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是否未发射任何数据。

img-IsEmpty

解析： 判断原始 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 发射的序列是否相等。

img-SequenceEqual

解析： 传递两个 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)

summary

This section describes the Rxjavaboolean (determines) the operator may return to the condition according to different booleanvalue types, for different Observable determination.

Tip : Rxjava2 version used above: 2.2.12

Rx introduction and explanation and complete catalog reference: Rxjava2 introduce and explain examples

Example code:

Download

Github

Gitee (Code Cloud)