RxJava操作符(7)-条件

All

All操作符对Observable发送的所有数据根据某个条件进行判断，当其发射出去的数据都满足该条件时，则返回true，否则返回false。

原理图如下：

All操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4).all(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                if (integer % 2 == 0) {
                    return true;
                } else {
                    return false;
                }
            }
        });
    }

运行代码，结果如下：

Amb

Amb操作符是对2到9个Observable进行处理，这些Observable会形成一种竞争关系，当哪个Observable最先发射出数据，则amb进行发射这个Observable里的数据，而其它的Observable将被丢弃。

原理图如下：

Amb操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.amb(createDelayObservable(4),
                createDelayObservable(3),
                createDelayObservable(2),
                createDelayObservable(1))
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread());
    }

    private Observable createDelayObservable(int index) {
        return Observable.just(1 * index, 2 * index, 3 * index).delay(index, TimeUnit.SECONDS);
    }

运行代码，结果如下：

Contains

Contains操作符判断Observable发射出去的数据是否包含某个数据，如果包含则返回true，如果Observable数据发射完了还没找到该数据，则返回false。

原理图如下：

Contains操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4).contains(3);
    }

运行代码，结果如下：

IsEmpty

IsEmpty操作符会判断Observable是否有发射过数据，如果有，则返回false；如果没有，则返回true。

原理图如下：

IsEmpty操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = createObservable(false).isEmpty();
    }

    private Observable createObservable(final boolean isNext) {
        return Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (isNext) {
                    subscriber.onNext(1);
                } else {
                    subscriber.onCompleted();
                }
            }
        });
    }

运行代码，结果如下：

DefaultIfEmpty

DefaultIfEmpty操作符会判断Observable是否有发射过数据，如果有，则返回发射出去的数据；如果没有，则发射自己定义好的数据。

原理图如下：

DefaultIfEmpty操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = createObservable(false).defaultIfEmpty(4);
    }

    private Observable createObservable(final boolean isNext) {
        return Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (isNext) {
                    subscriber.onNext(1);
                } else {
                    subscriber.onCompleted();
                }
            }
        });
    }

运行代码，结果如下：

SequenceEqual

SequenceEqual操作符比较两个Observable是否相同，如果相同则返回true；如果不相同则返回false。

原理图如下：

SequenceEqual操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.sequenceEqual(Observable.just(1, 2, 3),
                Observable.just(1, 2, 3));
    }

运行代码，结果如下：

SkipUntil

SkipUtil操作符是根据一个目标Observable为基准，当目标Observable没发射出去数据的时，原Observable发射出去的数据将会被忽略，当目标Observable发射数据时，则原Observable才开始发射数据。

原理图如下：

SkipUntil操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.interval(1, TimeUnit.SECONDS)
                .skipUntil(Observable.timer(5, TimeUnit.SECONDS))
                .observeOn(AndroidSchedulers.mainThread());
    }

运行代码，结果如下：

SkipWhile

SkipWhile操作符会根据定义的函数逻辑来判断是否跳过数据，当函数返回true时，则跳过数据，返回数据为false时，则发射数据。

原理图如下：

SkipWhile操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).skipWhile(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer != 3;
            }
        });
    }

运行代码，结果如下：

TakeUntil

TakeUtil操作符是根据一个目标Observable为基准，当目标Observable没发射出去数据的时，原Observable发射出去的数据将会发射，当目标Observable发射数据时，则原Observable的数据将被丢弃

原理图如下：

TakeUntil操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.interval(1, TimeUnit.SECONDS)
                .takeUntil(Observable.timer(5, TimeUnit.SECONDS))
                .observeOn(AndroidSchedulers.mainThread());
    }

运行代码，结果如下：

TakeWhile

TakeWhile操作符会根据定义的函数逻辑来判断是否跳过数据，当函数返回true时，则发射数据，返回数据为false时，则丢弃数据。

原理图如下：

TakeWhile操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).takeWhile(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer != 3;
            }
        });
    }

运行代码，结果如下：

接下来就是鸣谢了，非常感谢以下两位博主，相关链接如下：

https://mcxiaoke.gitbooks.io/rxdocs/content/operators/Conditional-and-Boolean-Operators.html

http://mushuichuan.com/2015/12/11/rxjava-operator-7/

github地址