RxJava学习笔记操作符学习（7）

条件 / 布尔操作符

• 作用

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

• 类型

类型图.png

• 具体操作符详解

1. all（）
   作用
   判断发送的每项数据是否都满足 设置的函数条件，若满足，返回 true；否则，返回 false
   事例

  public void RxJavaOperators(View view){
        Observable.just(1,2,3,4,12)
                .all(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer<10;
                    }
                }).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.e("sss","result is "+ aBoolean);
            }
        });
    }

2.takeWhile（）
作用
判断发送的每项数据是否满足 设置函数条件，若发送的数据满足该条件，则发送该项数据；否则不发送
事例

public void RxJavaOperators(View view){
        Observable.just(1,2,3,4,12)
                .all(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer<10;
                    }
                }).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.e("sss","result is "+ aBoolean);
            }
        });
    }

3.skipWhile（）
作用
判断发送的每项数据是否满足 设置函数条件，直到该判断条件 = false时，才开始发送Observable的数据。
事例

public void skipWhileOperators(View view){
        Observable.interval(1,TimeUnit.SECONDS)
                .skipWhile(new Predicate<Long>() {
                    @Override
                    public boolean test(Long aLong) throws Exception {
                        return aLong<6;
                    }
                }).subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.e("sss","发送了事件"+aLong);
            }
        });
    }

4. takeUntil（）
   作用
   执行到某个条件时，停止发送事件
   事例

public void takeUntilOperators(View view){
        Observable.interval(1,TimeUnit.SECONDS)
                .takeWhile(new Predicate<Long>() {
                    @Override
                    public boolean test(Long aLong) throws Exception {
                        return aLong>3;
                    }
                }).subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.e("sss","发送了事件"+aLong);
            }
        });
    }

5.skipUntil（）
作用
等到 skipUntil（） 传入的Observable开始发送数据，（原始）第1个Observable的数据才开始发送数据
事例

 public void skipUntilOperators(View view){
        Observable.interval(1,TimeUnit.SECONDS)
                .skipUntil(Observable.timer(5,TimeUnit.SECONDS))
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.e("sss","发送了事件"+aLong);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e("sss","对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.e("sss","对Complete事件作出响应");
                    }
                });
    }

6.SequenceEqual（）
作用
判定两个Observables需要发送的数据是否相同，若相同，返回 true；否则，返回 false。
事例

    public void SequenceEqualOperators(View view){
        Observable.sequenceEqual(Observable.just(1,2,3),
                Observable.just(1,2,3))
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e("sss","两个发送的事件"+aBoolean);
                    }
                });
    }

7.contains（）
作用
判断发送的数据中是否包含指定数据，若包含，返回 true；否则，返回 false，内部实现 = exists（）
事例

  public void containsOperators(View view){
        Observable.just(1,2,3,4,5)
                .contains(4)
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e("sss","result is "+ aBoolean);
                    }
                });
    }

8. isEmpty（）
   作用
   判断发送的数据是否为空，若为空，返回 true；否则，返回 false
   事例

   public void isEmptyOperators(View view){
      Observable.just(1,2,3,4)
              .isEmpty()
              .subscribe(new Consumer<Boolean>() {
                  @Override
                  public void accept(Boolean aBoolean) throws Exception {
                      Log.e("sss","result is "+ aBoolean);
                  }
              });
    }

9.amb（）
作用
当需要发送多个 Observable时，只发送 先发送数据的Observable的数据，而其余 Observable则被丢弃
事例

 public void ambOperators(View view){
        List<ObservableSource<Integer>> list=new ArrayList<>();
        list.add(Observable.just(1,2,3).delay(1,TimeUnit.SECONDS));
        list.add(Observable.just(4,5,6));
        // 一共需要发送2个Observable的数据
        // 但由于使用了amba（）,所以仅发送先发送数据的Observable
        // 即第二个（因为第1个延时了）第二个不发送了
        Observable.amb(list).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("sss", "接收到了事件 "+integer);
            }
        });
    }

10.defaultIfEmpty（）
作用
在不发送任何有效事件（ Next事件）、仅发送了 Complete 事件的前提下，发送一个默认值

 public void defaultIfEmptyOperators(View view){
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onComplete();
            }
        }).defaultIfEmpty(10)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e("sss","开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.e("sss","接收到了事件"+ integer  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e("sss", "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.e("sss", "对Complete事件作出响应");
                    }
                });
    }