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: skipWhile11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: skipWhile11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: E11-02 14:08:21.526 29654-29654/com.example.user.testproject I/RxJavaTest: D11-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: A11-02 14:24:02.505 11375-11396/com.example.user.testproject I/RxJavaTest: B11-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==A11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: OnComplete11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==B11-02 14:32:00.313 18417-18417/com.example.user.testproject I/RxJavaTest: takeWhile==C11-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");            }

则会输出全部，图：