Rxjava 条件/布尔操作符

public class RxConditionActivity extends AppCompatActivity {
    private final String TAG = RxConditionActivity.class.getSimpleName();
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //条件/布尔操作符的类型包括all(),contains(),isEmpty(),amb(),takeWhile(),
        // takeUntil(),skipWhile(),skipUntil(),defaultEmpty()sequenceEqual()
        /**
         * 判断发送的每项数据是否都满足 设置的函数条件
         * 只有都满足时，才返回true，有一个不满足就返回false
         */
        all();
        /**
         * 判断发送的每项数据是否满足设置的条件
         * 如果满足条件就发送该项数据，否则不发送,如果出现false，后面的事件就不再发送
         */
        takeWhile();
        /**
         * 判断发送的每项数据是否满足设置的函数条件
         * 直到该判断条件 = false时，才开始发送Observable的数据
         */
        skipWhile();
        /**
         * 执行到某个条件时，停止发送数据
         * 如果takeUntil(Observable)时，等到里面的Observable发送事件时，
         * 外层就会发送complete，停止发送事件
         */
        takeUntil();
        /**
         * 等到skipUntil传入的Observable发送数据时，第一个Observable才会发送数据
         */
        skipUntil();
        /**
         * 判断两个Observable需要发送的数据是否相同，如果相同返回true，否则返回false
         */
        sequenceEqual();
        /**
         * 判断数据是否在发送的数据之内，如果在返回true，否则返回false
         */
        contains();
        /**
         * 判断发送的数据是否为空，如果空返回true，否则返回false
         */
        isEmpty();
        /**
         * 当需要发送多个Observable时，只发送先发送的Observable的数据，
         * 则其余Observable的数据丢弃
         */
        amb();
        /**
         * 在不发送任何事件(onNext())时，只发送一个onComplete()事件时，添加一个默认值
         */
        defaultIfEmpty();
    }

    private void defaultIfEmpty() {
        Observable.empty()
                .defaultIfEmpty(15)
                .subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Object o) {
                        Log.e(TAG,"这是收到的默认值 value = " + o);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG,"这是收到的错误 " + e.getMessage());

                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG,"结束时间 onComplete");

                    }
                });
    }

    private void amb() {
        List<Observable<Long>> observables = new ArrayList<>(2);
        observables.add(Observable.timer(2,TimeUnit.SECONDS));
        observables.add(Observable.rangeLong(3,2));
        Observable.amb(observables)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG,"我就想知道发送的是什么玩意 value = " + aLong);
                    }
                });
    }

    private void isEmpty() {
        Observable.just(1,2,3,4,5,6)
                .isEmpty()
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e(TAG,"发送的数据是否为空 结果为 = " + aBoolean);
                    }
                });

    }

    private void contains() {
        Observable.just(1,2,3,4,5)
                .contains(5)
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e(TAG,"判断数据是否在发送的数据内 result = " + aBoolean);

                    }
                });
    }

    private void sequenceEqual() {
        Observable.sequenceEqual(Observable.just(1,2,3,4),
                Observable.just(1,2,3,4)
                ).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.e(TAG,"判断的结果为 result = " + aBoolean);
            }
        });
    }

    private void skipUntil() {
        Observable.intervalRange(1,10,1,1,TimeUnit.SECONDS)
                .skipUntil(Observable.timer(5, TimeUnit.SECONDS))
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long integer) throws Exception {
                        Log.e(TAG,"通过的事件为 value = " + integer);
                    }
                });
    }

    private void takeUntil() {
        Log.e(TAG,"-------------------takeUntil---------------------");

        Observable.just(1,2,3,4,5,6)
                .takeUntil(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        Log.e(TAG,"value = " + integer);
                        return integer > 3;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG,"接收到的数据为 " + integer);
            }
        });
    }

    private void skipWhile() {
        Log.e(TAG,"-------------------skipWhile---------------------");

        Observable.just(1,2,3,4,5,6,7)
                .skipWhile(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer % 2 != 0;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG,"这是接收到的数据 value =  " + integer);
            }
        });
    }

    private void takeWhile() {
        Log.e(TAG,"-------------------takeWhile---------------------");
        Observable.just(1,2,3,4,5,6,7)
                .takeWhile(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        boolean result = integer % 2 != 0;
                        Log.e(TAG,"integer = " + integer + "  result = " + result);
                        return result;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG,"发送数据中的偶数为  " + integer);
            }
        });
    }

    private void all() {
        Observable.just(1,2,3,4,5,6)
                .all(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer < 5 ;
                    }
                }).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.e(TAG,"all的结果为" + aBoolean);
            }
        });
    }
}