7、Rxjava-条件（布尔）操作符

作用

通过设置函数，判断被观察者（Observable）发送的事件是否符合条件

类型

ofType()：只发射指定类型的事件

Observable.just(1, "2")
        .all(new Predicate<Serializable>() {
            @Override
            public boolean test(Serializable serializable) throws Exception {
                return serializable instanceof String;
            }
        })
        .subscribe(new SingleObserver<Boolean>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "函数条件 onSubscribe");
            }

            @Override
            public void onSuccess(Boolean aBoolean) {
                Log.d(TAG, "函数条件：" + aBoolean);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "函数条件 onError");
            }
        });

>>>>>>
函数条件 onSubscribe
函数条件：false
>>>>>>

takeWhile()：开始满足函数条件才发射数据，直到不满足则停止发射,后续无论是否满足条件都不再发射

Observable.just(1, 2, 3, 1, 2, 3)
        .takeWhile(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.d(TAG, "满足函数条件的数据：" + integer);
            }
        });
        
        
>>>>>>
>>>>>>

takeUntil()：直到满足函数条件就停止发射,后续无论是否满足条件都不再发射

Observable.just(1, 2, 3, 1, 2, 3)
        .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.d(TAG, "满足函数条件的数据：" + integer);
            }
        });
        
        
>>>>>>
满足函数条件的数据：1
满足函数条件的数据：2
满足函数条件的数据：3
>>>>>>

skipWhile()：丢弃发射的数据直到不满足函数条件才开始发射,后续所有的数据发射出来

Observable.just(1, 2, 3, 1, 2, 3)
        .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.d(TAG, "满足函数条件的数据：" + integer);
            }
        });
        
        
>>>>>>
满足函数条件的数据：3
满足函数条件的数据：1
满足函数条件的数据：2
满足函数条件的数据：3
>>>>>>

skipUntil()：直到第二个Observable发射数据第一个Observable才会发射，之前的会丢弃掉

Observable.just(1, 2, 3, 1, 2, 3)
        .skipUntil(new ObservableSource<Object>() {
            @Override
            public void subscribe(Observer<? super Object> observer) {
                Observable.timer(1, TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(TAG, "延迟一秒发射");
                    }
                });
            }
        })
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "满足函数条件的数据：" + integer);
            }
        });
        
        
>>>>>>
延迟一秒发射
>>>>>>

sequenceEqual()：判定两个Observables需要发送的数据是否相同

Observable.sequenceEqual(Observable.just(1), Observable.just(1))
        .subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.d(TAG, "是否满足条件：" + aBoolean);
            }
        });
        
        
>>>>>>
是否满足条件：true
>>>>>>

contains()：判断发送的数据中是否包含指定数据

Observable.just(1, 2, 3, 1, 2, 3)
        .contains(1)
        .subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.d(TAG, "是否满足条件：" + aBoolean);
            }
        });
        
        
>>>>>>
是否满足条件：true
>>>>>>

isEmpty()：判断发送的数据是否为空

Observable.empty()
        .isEmpty()
        .subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.d(TAG, "是否满足条件：" + aBoolean);
            }
        });
        
        
>>>>>>
是否满足条件：true
>>>>>>

defaultIfEmpty()：如果发送的数据为空，则发射一个默认值

Observable.empty()
        .defaultIfEmpty(99)
        .subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object object) throws Exception {
                Log.d(TAG, "满足函数条件的数据：" + object);
            }
        });
        
        
>>>>>>
满足函数条件的数据：99
>>>>>>