RxJava的布尔操作符实例

布尔操作符

我们可以使用布尔操作符，对源数据Observable发送的数据进行变换或者是直接的布尔操作，来达到一些目的。

all 操作符

Observable<Boolean> all(Func1<? super T, Boolean> predicate)

用于判断Observable的所有数据是否满足某一个条件
例如：

 Observable.range(10,3).all(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer>9;
            }
        }).subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                Log.i(TAG, "all" + aBoolean.toString());
            }
        });

输出是true，加入把条件改为

@Override
            public Boolean call(Integer integer) {
                return integer>11;
            }

那么就是输出false了。
图：

amb 操作符

Observable<T> amb(Iterable<? extends Observable<? extends T>> sources)
Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2)
Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3)
...... 还有其他的，同样是上面哪样子的

amb操作符的作用是用于比较两个Observable，然后哪一个先发射数据就只是发射这个Observable的数据，抛弃其他的Observable数据，不论他第一个是发射了onError还是onComplete，例子：

Observable<Integer> o1 = Observable.range(20, 1).delay(200, TimeUnit.MILLISECONDS);
        Observable<Integer> o2 = Observable.range(10, 1).delay(100, TimeUnit.MILLISECONDS);

        Observable.amb(o1, o2).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.i(TAG, "amb==" + integer.toString());
            }
        });

输出：

 amb==10

有一个ambWith操作符：

Observable<T> ambWith(Observable<? extends T> t1)

他是一个非静态的，作用跟上面的一样。
图：

contains 操作符

Observable<Boolean> contains(final Object element)

该操作符的作用是用于判断源数据时候包含某一个元素，例如：

   Observable.range(10,5).contains(11).subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                Log.i(TAG,aBoolean.toString());
            }
        });

输出是true，因为源数据的范围是10-14之间，包含11.
图：

defaultIfEmpty 操作符

Observable<T> defaultIfEmpty(final T defaultValue)

该操作符的作用是在源Observable没有发射数据的时候发射一个默认数据，但是有onComplete()调用，表明他已经发射数据完毕，在没有数据发射的时候调用了onError是不会发射默认数据的，例如：

 Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onCompleted();
//                subscriber.onError(new IllegalArgumentException("error"));
            }
        });
        ob.defaultIfEmpty("A").subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, s);
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.i(TAG, throwable.getMessage());
            }
        });

结果是：A，假如是发射onError的时候则是只输出“error”，而不会输出A
图：

sequenceEqual 操作符

Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second)
Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality)

第一个函数，用于判断输入的两个Observable是否相同，包括发射长度，顺序，值，终止状态，例如：

Observable.sequenceEqual(Observable.just("A","B"),Observable.just("A","B")).subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                Log.i(TAG, aBoolean.toString());
            }
        });

输出就是true，把第二个Observable改为Observable.just(“B”,”A”)，输出就是false。
终止状态不同的时候，比如：

Observable<String> o1 = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("A");
                subscriber.onCompleted();
            }
        });
        Observable<String> o2 = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("A");
                subscriber.onError(new IllegalArgumentException("Error"));
            }
        });

        Observable.sequenceEqual(o1,o2).subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                Log.i(TAG, aBoolean.toString());
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.i(TAG, throwable.getMessage());
            }
        });

就会输出了error。
第二个函数，他多了一个参数，是用于比较，自己确定规则的那种比较，两个Observable的值是否相同。例如：

 Observable.sequenceEqual(Observable.just("A"), Observable.just("A"), new Func2<String, String, Boolean>() {
            @Override
            public Boolean call(String s, String s2) {
                return s.equals(s2);
            }
        }).subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                Log.i(TAG, aBoolean.toString());
            }
        });

就是输出true，
图：

skipUntil 操作符

Observable<T> skipUntil(Observable<U> other)

用于废弃源Observable，知道other操作符符发射数据，例如：

Observable<String> s1 = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("C");
                subscriber.onNext("E");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext("D");
            }
        });
        s1.subscribeOn(Schedulers.newThread())
                .skipUntil(Observable.just("B")
                .delay(100, TimeUnit.MILLISECONDS))
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });

输出结果是只输出了D，以为前面的C，E在other发射数据之前已经发射，所以会被丢弃。
图：

skipWhile 操作符

Observable<T> skipWhile(Func1<? super T, Boolean> predicate)

他的作用在于可以自己定规则，忽略前面不符合条件的数据，但是当一旦返回了true，该数据就不会被发射，然后predicate谓词还是会被调用，但是当predicate返回了false之后就不会再次被调用。例如：

Observable<String> s1 = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("C");
                subscriber.onNext("E");
                subscriber.onNext("D");
                subscriber.onNext("F");
                subscriber.onCompleted();
            }
        });
        s1.skipWhile(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                Log.i(TAG, "skipWhile");
                return s.equals("C");
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, s);
            }
        });

输出：

11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: skipWhile
11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: skipWhile
11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: E
11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: D
11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: F

可以看到C没有输出，而且调用了skipWhile两次，skipWhile返回了false之后就没有被再次调用而是直接发射了源Observable后面的数据。
图：

TakeUntil 操作符

Observable<T> takeUntil(Observable<? extends E> other)

他的作用在于other在发射一个数据或者是onComplete的时候，回去终止源Observable发射数据，例如：

  Observable<String> o1 = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("A");
                subscriber.onNext("B");
                subscriber.onNext("C");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext("D");
            }
        });
        o1.subscribeOn(Schedulers.newThread())
                .takeUntil(Observable.empty().delay(100, TimeUnit.MILLISECONDS))
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });

输出结果：

11-02 14:24:02.505 11375-11396/com.example.user.testproject I/RxJavaTest: A
11-02 14:24:02.505 11375-11396/com.example.user.testproject I/RxJavaTest: B
11-02 14:24:02.505 11375-11396/com.example.user.testproject I/RxJavaTest: C

可以看到other是在100ms之后再去发射数据的，observable在100ms之后发射的数据会被忽略。图：

.### TakeWhile 操作符

Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)

他的作用是通过predicate函数返回一个boolean值，假如是返回了true，则发射该数据，但是一旦返回来false，就终止源Observable的发射，同时调用他的onComplete()方法，例子：

Observable<String> o1 = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("A");
                subscriber.onNext("B");
                subscriber.onNext("C");
                subscriber.onNext("D");
                subscriber.onCompleted();
            }
        });
        o1.takeWhile(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                Log.i(TAG, "takeWhile=="+s);
                return s.equals("C");
            }

        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, s);
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {

            }
        }, new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "OnComplete");
            }
        });

输出结果：

11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==A
11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: OnComplete
11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==B
11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==C
11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==D

因为第一个数据就使得predicate返回了false，所以终止了发射，假如predicate换成：

 @Override
            public Boolean call(String s) {
                Log.i(TAG, "takeWhile==" + s);
                return !s.equals("E");
            }

则会输出全部，图：