RxJava2.0 操作符（7）—— Conditional and Boolean 条件操作符

7.1 All

判定是否 Observable 发射的所有数据都满足某个条件。

All

传递一个谓词函数给 All 操作符，这个函数接受原始 Observable 发射的数据，根据计算返回一个布尔值。All 返回一个只发射一个单个布尔值的 Observable，如果原始 Observable 正常终止并且每一项数据都满足条件，就返回 true；如果原始 Observable 的任何一项数据不满足条件就返回 False。

示例代码：

Observable.just(1,4,6,8).all(new Predicate() {
        @Override
        public boolean test(@NonNull Integer integer) throws Exception {
    //      return integer <= 10;
            return integer < 10 && integer > 5;
        }
    }).subscribe(new Consumer() {
        @Override
        public void accept(@NonNull Boolean aBoolean) throws Exception {
            Log.e(TAG, "accept : " + aBoolean);
        }
    });

输出结果：

accept : false

7.2 Amb

给定两个或多个 Observables，它只发射首先发射数据或通知的那个 Observable 的所有数据.

Amb

当你传递多个 Observable 给 Amb 时，它只发射其中一个 Observable 的数据和通知：首先发送通知给 Amb 的那个，不管发射的是一项数据还是一个 onError 或 onCompleted 通知。Amb 将忽略和丢弃其它所有 Observables 的发射物。

7.2.1 Amb

示例代码：

Observable ob1 = Observable.range(1, 3).delay(150, TimeUnit.MILLISECONDS);
Observable ob2 = Observable.range(4, 5).delay(200, TimeUnit.MILLISECONDS);
Observable ob3 = Observable.range(6, 10).delay(250, TimeUnit.MILLISECONDS);
List> obs = new ArrayList<>();
obs.add(ob1);
obs.add(ob2);
obs.add(ob3);
Observable.amb(obs).subscribe(new Consumer() {
    @Override
    public void accept(@NonNull Integer integer) throws Exception {
        Log.e(TAG, "accept : " + integer);
    }
});

输出结果：

accept : 1
accept : 2
accept : 3

7.2.2 AmbArray

示例代码：

Observable ob1 = Observable.range(1, 3).delay(150, TimeUnit.MILLISECONDS);
Observable ob2 = Observable.range(4, 5).delay(200, TimeUnit.MILLISECONDS);
Observable ob3 = Observable.range(6, 10).delay(250, TimeUnit.MILLISECONDS);
Observable.ambArray(ob1,ob2,ob3).subscribe(new Consumer() {
    @Override
    public void accept(@NonNull Integer integer) throws Exception {
        Log.e(TAG, "accept : " + integer);
    }
});

输出结果：

accept : 1
accept : 2
accept : 3

7.2.3 AmbWith

示例代码：

Observable ob1 = Observable.range(1, 3).delay(150, TimeUnit.MILLISECONDS);
Observable ob2 = Observable.range(4, 5).delay(200, TimeUnit.MILLISECONDS);
//  Observable ob3 = Observable.range(6, 10).delay(250, TimeUnit.MILLISECONDS);
ob1.ambWith(ob2).subscribe(new Consumer() {
    @Override
    public void accept(@NonNull Integer integer) throws Exception {
        Log.e(TAG, "accept : " + integer);
    }
});

输出结果：

accept : 1
accept : 2
accept : 3

7.3 Contains

判定一个 Observable 是否发射一个特定的值

Contains

Contains 操作符用来判断源 Observable 所发射的数据是否包含某一个数据，如果包含会返回 true，如果源 Observable 已经结束了却还没有发射这个数据则返回 false。

7.3.1 any

返回一个 Observable，如果源 ObservableSource 发出的任何项目满足指定的条件，则返回 true，否则为 false。 注意：如果源 ObservableSource 为空，这将总是发生错误。

any

示例代码：

 /**
 * 只要其中任何一项是满足条件的，则返回为true
 */
Observable.just(1,4,10).any(new Predicate() {
        @Override
        public boolean test(@NonNull Integer integer) throws Exception {
//           return integer < 0;
            return integer > 8;
        }
    }).subscribe(new Consumer() {
        @Override
        public void accept(@NonNull Boolean aBoolean) throws Exception {
            Log.e(TAG, "accept : " + aBoolean);
        }
    });

输出结果：

accept : true

7.3.2 Contains

给 Contains 传一个指定的值，如果原始 Observable 发射了那个值，它返回的 Observable 将发射 true，否则发射 false。

contains

示例代码：

Observable.just("h","e","l","l","o").contains("e").subscribe(new Consumer() {
        @Override
        public void accept(@NonNull Boolean aBoolean) throws Exception {
            Log.e(TAG, "accept : " + aBoolean);
        }
    });

输出结果：

accept : true

7.3.3 isEmpty

判定原始 Observable 是否没有发射任何数据。

isEmpty

示例代码：

Observable.empty().isEmpty().subscribe(new Consumer() {
        @Override
        public void accept(@NonNull Boolean aBoolean) throws Exception {
            Log.e(TAG, "accept : " + aBoolean);
        }
    });

输出结果：

accept : true

7.4 DefaultIfEmpty

发射来自原始 Observable 的值，如果原始 Observable 没有发射任何数据，就发射一个默认值。

DefaultIfEmpty

7.4.1 DefaultIfEmpty

DefaultIfEmpty 简单的精确地发射原始 Observable 的值，如果原始 Observable 没有发射任何数据正常终止（以 onCompleted 的形式），DefaultIfEmpty 返回的 Observable 就发射一个你提供的默认值。
示例代码：

Observable ob1 = Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(@NonNull ObservableEmitter e) throws Exception {
//          e.onNext(110);
            e.onComplete();
        }
    });
//  Observable ob1 = Observable.empty();
ob1.defaultIfEmpty(250).subscribe(new Consumer() {
    @Override
    public void accept(@NonNull Integer integer) throws Exception {
        Log.e(TAG, "accept:" + integer);
    }
});

输出结果：

accept:250

7.4.2 SwitchIfEmpty

如果原始 Observable 没有发射任何数据，则返回另一个新的 Observable。
示例代码：

Observable ob1 = Observable.empty();
ob1.switchIfEmpty(Observable.just(110, 119)).subscribe(new Consumer() {
    @Override
    public void accept(@NonNull Integer integer) throws Exception {
        Log.e(TAG, "accept:" + integer);
    }
});

输出结果：

accept:110
accept:119

7.5 SequenceEqual

判定两个 Observables 是否发射相同的数据序列。

SequenceEqual

传递两个 Observable 给 SequenceEqual 操作符，它会比较两个 Observable 的发射物，如果两个序列是相同的（相同的数据，相同的顺序，相同的终止状态），它就发射 true，否则发射 false。

示例代码：

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

输出结果：

accept:false

7.5 SkipUntil

丢弃原始 Observable 发射的数据，直到第二个 Observable 发射了一项数据。

SkipUntil

SkipUntil 订阅原始的 Observable，但是忽略它的发射物，直到第二个 Observable 发射了一项数据时，它开始发射原始 Observable。
示例代码：

Observable.interval(100, TimeUnit.MILLISECONDS)
    .take(6)
    .skipUntil(Observable.just(10,30).delay(330, TimeUnit.MILLISECONDS))
    .subscribe(new Consumer() {
        @Override
        public void accept(@NonNull Long aLong) throws Exception {
            Log.e(TAG, "accept:" + aLong);
        }
    });

输出结果：

accept:3
accept:4
accept:5

7.6 SkipWhile

丢弃Observable发射的数据，直到一个指定的条件不成立

SkipWhile

SkipWhile 订阅原始的 Observable，但是忽略它的发射物，直到你指定的某个条件变为 false 的那一刻，它开始发射原始 Observable。
示例代码：

Observable.interval(100, TimeUnit.MILLISECONDS)
    .take(6)
    .skipWhile(new Predicate() {
        @Override
        public boolean test(@NonNull Long aLong) throws Exception {
            //当返回 false 时，原Observable开始发射。
            return aLong < 3;
        }
    })
    .subscribe(new Consumer() {
        @Override
        public void accept(@NonNull Long aLong) throws Exception {
            Log.e(TAG, "accept:" + aLong);
        }
    });

输出结果：

accept:3
accept:4
accept:5

7.7 TakeUntil

当第二个 Observable 发射了一项数据或者终止时，丢弃原始 Observable 发射的任何数据

TakeUntil

TakeUntil 订阅并开始发射原始 Observable，它还监视你提供的第二个 Observable。如果第二个 Observable 发射了一项数据或者发射了一个终止通知，TakeUntil 返回的 Observable 会停止发射原始 Observable 并终止。与 SkipUntil 功能相反。

RxJava2.0 中的实现的 TakeUntil 操作符有两个变体：

• takeUntil(Observable)： 第二个 Observable 发射一项数据或一个 onError 通知或一个 onCompleted 通知都会导致 takeUntil 停止发射数据。

takeUntil(Observable)

示例代码：

Observable.interval(100, TimeUnit.MILLISECONDS)
    .take(6).takeUntil(Observable.just(110, 250)
    .delay(330,TimeUnit.MILLISECONDS)).subscribe(new Consumer() {
        @Override
        public void accept(@NonNull Long aLong) throws Exception {
            Log.e(TAG, "accept:" + aLong);
        }
    });

输出结果：

accept:0
accept:1
accept:2

• takeUntil(Predicate）： 返回一个 Observable，它发出源 Observable 发出的项目，检查每个项目的指定谓词，然后在条件满足时完成。这个操作符和 takeWhile（Predicate）之间的区别在于，这个条件在项目发出后被评估。类似于 do...while 与 if 的区别。

takeUntil(Predicate）

示例代码 2：

Observable.just(1L,2L,5L,2L).takeUntil(new Predicate() {
        @Override
        public boolean test(@NonNull Long aLong) throws Exception {
            //当其中有一项返回 false 时，原 Observable 终止发射，不包括最后一项
            return aLong > 3;
        }
    }).subscribe(new Consumer() {
        @Override
        public void accept(@NonNull Long aLong) throws Exception {
            Log.e(TAG, "accept:" + aLong);
        }
    });

输出结果：

accept:1
accept:2
accept:5

7.8 takeWhile

发射 Observable 发射的数据，直到一个指定的条件不成立 。

takeWhile

RxJava 中的 takeWhile 操作符返回一个镜像原始 Observable 行为的 Observable，直到某一项数据你指定的函数返回 false 那一刻，这个新的 Observable 发射 onCompleted 终止通知。与 SkipWhile 功能相反。

示例代码：

 Observable.just(1L,2L,5L,2L)
    .takeWhile(new Predicate() {
        @Override
        public boolean test(@NonNull Long aLong) throws Exception {
            //当其中有一项返回 false 时，原 Observable 终止发射，包括当前最后一项
            return aLong < 3;
        }
    }).subscribe(new Consumer() {
        @Override
        public void accept(@NonNull Long aLong) throws Exception {
            Log.e(TAG, "accept:" + aLong);
        }
    });

输出结果：

accept:1
accept:2