Android RxJava2(六)条件操作符

Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。因此在学习过程中全面的了解了下RxJava的条件操作符

all()

方法：

public final Single<Boolean> all(Predicate<? super T> predicate)

作用：
判断被观察者所有事件是否满足某个事件，如果全部满足则返回true，都在返回false
代码：

        Observable.just(1,3,5).all(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer % 2 == 1;
            }
        }).subscribe(new Consumer<Boolean>() {// Consumer是简易版的Observer，这里调用的只接收onNext方法
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.e("---","accept:"+aBoolean);
            }
        });

打印结果：

E/---: accept:true

takeUntil()

原理图：

方法：

public final Observable<T> takeUntil(Predicate<? super T> stopPredicate) 

作用：
当事件满足设定的条件时，该事件的下一个事件不会被发送了。也就是说当condition == false的时候终止，包含临界条件的item
代码：

        Observable.just(1,3,5).takeUntil(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer > 2;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("---","accept:"+integer);
            }
        });

打印结果：

E/---: accept:1
       accept:3

skipUntil()

原理图：

方法：

public final <U> Observable<T> skipUntil(ObservableSource<U> other)

作用：
当skipUntil里面的参数Observable发送事件的时候，源被观察者才会发送事件。
代码：

        Observable.intervalRange(1,10,1,1,TimeUnit.SECONDS)
                .skipUntil(Observable.intervalRange(20,3,5,1,TimeUnit.SECONDS))
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e("---","accept:"+aLong);
                    }
                });

结果打印：

06-08 14:17:43.340 26552-26577/ E/---: accept:6
06-08 14:17:44.340 26552-26577/ E/---: accept:7
06-08 14:17:45.340 26552-26577/ E/---: accept:8
06-08 14:17:46.340 26552-26577/ E/---: accept:9
06-08 14:17:47.340 26552-26577/ E/---: accept:10

从上面打印结果可以发现，观察者接收到的数据和skipUntil的参数被观察者发送的数据没有关系，仍然是源被观察者数据。

takeWhile()

原理图：

方法：

public final Observable<T> takeWhile(Predicate<? super T> predicate)

作用：
可以设置条件，当某个数据满足条件时就会发送该数据，反之则不发送。当condition == false的时候终止，不包含临界条件的item
代码：

        Observable.just(1,2,3,4).takeWhile(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer < 3;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("---","accept:"+integer);
            }
        });

打印结果：

E/---: accept:1
       accept:2

skipWhile()

原理图：

方法：

public final Observable<T> skipWhile(Predicate<? super T> predicate)

作用：
可以设置条件，当某个数据满足条件时不发送该数据，反之则发送。
代码：

        Observable.just(1,2,3,4).skipWhile(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer < 3;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("---","accept:"+integer);
            }
        });

打印结果：

E/---: accept:3
       accept:4

sequenceEqual()

原理图：

方法：

public static <T> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2)

作用：
判断两个 Observable 发送的事件是否相同。
代码：

        Observable.sequenceEqual(Observable.just(1,2),Observable.just(1,2))
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e("---","accept:"+aBoolean);
                    }
                });

结果打印:

E/---: accept:true

contains()

原理图：

方法：

public final Single<Boolean> contains(final Object element)

作用：
判断发送的事件中是否包含某个元素，有则返回true
代码：

        Observable.just(1,3,5).contains(3).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.e("---","accept:"+aBoolean);
            }
        });

打印结果：

E/---: accept:true

isEmpty()

原理图：

方法：

public final Single<Boolean> isEmpty()

作用：
判断事件序列是否为空。
代码：

Observable.create(new ObservableOnSubscribe < Integer > () {
    @Override
    public void subscribe(ObservableEmitter < Integer > e) throws Exception {
        e.onComplete();
    }
})
.isEmpty()
.subscribe(new Consumer < Boolean > () {
    @Override
    public void accept(Boolean aBoolean) throws Exception {
       Log.e("---","accept:"+aBoolean);
    }
});

结果打印：

Log.e("---","accept:"+aBoolean);

defaultIfEmpty()

方法：

public final Observable<T> defaultIfEmpty(T defaultItem)

作用：
如果观察者只发送一个 onComplete() 事件，则可以利用这个方法发送一个值。
代码：

Observable.create(new ObservableOnSubscribe < Integer > () {
    @Override
    public void subscribe(ObservableEmitter < Integer > e) throws Exception {
        e.onComplete();
    }
})
.defaultIfEmpty(666)
.subscribe(new Consumer < Integer > () {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d( "---"，"---"+integer);
    }
});

打印结果：

E/---: ---666

amb()

原理图：

方法：

public static <T> Observable<T> amb(Iterable<? extends ObservableSource<? extends T>> sources)

作用：
amb() 要传入一个 Observable 集合，但是只会发送最先发送事件的 Observable 中的事件，其余 Observable 将会被丢弃。
代码：

        List<Observable<Long>> list = new ArrayList<>();
        list.add(Observable.intervalRange(5,3,5,1,TimeUnit.SECONDS));
        list.add(Observable.intervalRange(1,3,3,1,TimeUnit.SECONDS));
        Observable.amb(list).subscribe(new Consumer<Long>() {

            @Override
            public void accept(Long aLong) throws Exception {
                Log.e("---","accept:"+aLong);
            }
        });

打印结果：

06-08 16:00:17.961 10456-10481/ E/---: accept:1
06-08 16:00:18.961 10456-10481/ E/---: accept:2
06-08 16:00:19.958 10456-10481/ E/---: accept:3