1 作用
通过设置函数，判断被观察者（Observable）发送的事件是否符合条件
2 分类
RxJava2中，条件 / 布尔操作符的类型包括：
| 类型 | 作用 | 备注 |
|---|---|---|
| all() | 判断发送的每项数据是否满足函数条件 | 若满足，返回true。否则返回false |
| takeWhile() | 判断发送的每项数据是否满足函数条件 | * 若发送的数据满足该条件，则发送该项数据。否则停止发送 |
| skipWhile() | 判断发送的每项数据是否满足函数条件 | 直到该判断条件=false时，才开始发送Observable的数据 |
| takeUntil() | 等到takeUntil()传入的Observable开始发送数据，（原始）第一个Observable的数据停止发送数据 | |
| skipUntil() | 等到skipUntil()传入的Observable开始发送数据，（原始）第一个Observable的数据开始发送数据 | |
| SequenceEqual() | 判定两个Observable需要发送的数据是否相同 | 若相同，则返回true。否则，返回false |
| contains() | 判断发送的数据中是否包含指定数据 | 若包含，返回true。否则，返回false |
| isEmpty() | 判断发送的数据是否为空 | 若为空，返回true。否则，返回false |
| amb() | 当需要发送多个Observable时，只发送先发送数据的Observable的数据，而其余Observable则被丢弃 | |
| defaultIfEmpty() | 在不发送任何有效事件（Next事件）、仅发送Complete事件的前提下，发送一个默认值 |
- 注：在使用
RxJava 2操作符前，记得在项目的Gradle中添加依赖：
dependencies {
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
compile 'io.reactivex.rxjava2:rxjava:2.0.7'
// 注：RxJava2 与 RxJava1 不能共存，即依赖不能同时存在
}
3 类型
2.1 all（）
- 作用
判断发送的每项数据是否都满足 设置的函数条件
若满足，返回
true；否则，返回false
Observable.just(1,2,3,4,5,6)
.all(new Predicate(){
@Override
public boolean test( Integer integer) throws Exception {
return (integer<=10);
// 该函数用于判断Observable发送的10个数据是否都满足integer<=10
}
}).subscribe(new Consumer() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.d(TAG,"result is "+ aBoolean);
// 输出返回结果
}
});
-
测试结果
因为所有数据都满足函数内条件 （每项数据<=10）
QQ截图20180715184515.png
3.2 takeWhile（）
- 作用
判断发送的每项数据是否满足 设置函数条件
- 若发送的数据满足该条件，则发送该项数据；否则不发送
- 具体代码
// 1. 每1s发送1个数据 = 从0开始，递增1，即0、1、2、3
Observable.interval(1, TimeUnit.SECONDS)
// 2. 通过takeWhile传入一个判断条件
.takeWhile(new Predicate(){
@Override
public boolean test( Long integer) throws Exception {
return (integer<3);
// 当发送的数据满足<3时，才发送Observable的数据
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long value) {
Log.d(TAG,"发送了事件 "+ value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
-
测试结果
QQ截图20180715184913.png
3.3 skipWhile（）
- 作用
判断发送的每项数据是否满足 设置函数条件
直到该判断条件 =
false时，才开始发送Observable的数据
- 具体使用
// 1. 每隔1s发送1个数据 = 从0开始，每次递增1
Observable.interval(1, TimeUnit.SECONDS)
// 2. 通过skipWhile（）设置判断条件
.skipWhile(new Predicate(){
@Override
public boolean test( Long aLong) throws Exception {
return (aLong<5);
// 直到判断条件不成立 = false = 发射的数据≥5，才开始发送数据
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long value) {
Log.d(TAG,"发送了事件 "+ value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
- 测试结果
QQ截图20180715185142.png
3.4 takeUntil（）
- 作用
执行到某个条件时，停止发送事件 - 具体使用
// 1. 每1s发送1个数据 = 从0开始，递增1，即0、1、2、3
Observable.interval(1, TimeUnit.SECONDS)
// 2. 通过takeUntil的Predicate传入判断条件
.takeUntil(new Predicate(){
@Override
public boolean test( Long integer) throws Exception {
return (integer>3);
// 返回true时，就停止发送事件
// 当发送的数据满足>3时，就停止发送Observable的数据
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long value) {
Log.d(TAG,"发送了事件 "+ value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
-
测试结果
944365-3433f8b47317c4d2.gif
该判断条件也可以是Observable，即 等到 takeUntil（） 传入的Observable开始发送数据，（原始）第1个Observable的数据停止发送数据
// （原始）第1个Observable：每隔1s发送1个数据 = 从0开始，每次递增1
Observable.interval(1, TimeUnit.SECONDS)
// 第2个Observable：延迟5s后开始发送1个Long型数据
.takeUntil(Observable.timer(5, TimeUnit.SECONDS))
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Long value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
- 测试结果
当第 5s 时，第2个Observable开始发送数据，于是（原始）第1个Observable停止发送数据
QQ截图20180715185704.png
3.5 skipUntil（）
- 作用
等到skipUntil（）传入的Observable开始发送数据，（原始）第1个Observable的数据才开始发送数据
// （原始）第1个Observable：每隔1s发送1个数据 = 从0开始，每次递增1
Observable.interval(1, TimeUnit.SECONDS)
// 第2个Observable：延迟5s后开始发送1个Long型数据
.skipUntil(Observable.timer(5, TimeUnit.SECONDS))
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Long value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
- 测试结果
5s后（ skipUntil（） 传入的Observable开始发送数据），（原始）第1个Observable的数据才开始发送
QQ截图20180715185934.png
3.6 SequenceEqual（）
- 作用
判定两个Observables需要发送的数据是否相同
若相同，返回
true；否则，返回false
Observable.sequenceEqual(
Observable.just(4,5,6),
Observable.just(4,5,6)
)
.subscribe(new Consumer() {
@Override
public void accept( Boolean aBoolean) throws Exception {
Log.d(TAG,"2个Observable是否相同："+ aBoolean);
// 输出返回结果
}
});
QQ截图20180715190113.png
3.7 contains（）
- 作用
判断发送的数据中是否包含指定数据
- 若包含，返回
true；否则，返回false- 内部实现 =
exists（）
Observable.just(1,2,3,4,5,6)
.contains(4)
.subscribe(new Consumer() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.d(TAG,"result is "+ aBoolean);
// 输出返回结果
}
});
-
测试结果
因为发送的数据中包含4
QQ截图20180715190537.png
3.8 isEmpty（）
- 作用
判断发送的数据是否为空
若为空，返回
true；否则，返回false
Observable.just(1,2,3,4,5,6)
.isEmpty() // 判断发送的数据中是否为空
}).subscribe(new Action1() {
@Override
public void call(Boolean aBoolean) {
Log.d(TAG,"result is "+ aBoolean);
// 输出返回结果
}
});
-
测试结果
因为发送的数据不为空
QQ截图20180715190744.png
3.9 amb（）
参考
Android RxJava：详解 条件 / 布尔操作符
- 作用
当需要发送多个Observable时，只发送 先发送数据的Observable的数据，而其余Observable则被丢弃
// 设置2个需要发送的Observable & 放入到集合中
List> list= new ArrayList <>();
// 第1个Observable延迟1秒发射数据
list.add( Observable.just(1,2,3).delay(1,TimeUnit.SECONDS));
// 第2个Observable正常发送数据
list.add( Observable.just(4,5,6));
// 一共需要发送2个Observable的数据
// 但由于使用了amba（）,所以仅发送先发送数据的Observable
// 即第二个（因为第1个延时了）
Observable.amb(list).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "接收到了事件 "+integer);
}
});
-
测试结果
即只发送了先发送数据的Observable的数据 = 4，5，6
QQ截图20180715191126.png
3.10 defaultIfEmpty（）
- 作用
在不发送任何有效事件（Next事件）、仅发送了Complete事件的前提下，发送一个默认值 - 具体使用
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
// 不发送任何有效事件
// e.onNext(1);
// e.onNext(2);
// 仅发送Complete事件
e.onComplete();
}
}).defaultIfEmpty(10) // 若仅发送了Complete事件，默认发送 值 = 10
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
-
测试结果
QQ截图20180715191424.png
参考
Android RxJava：详解 条件 / 布尔操作符