接上篇,还剩过滤性操作符和条件布尔操作符未讲。
过滤性操作符
过滤性操作符:按照一定的条件过滤事件,主要包括以下几类:
条件过滤操作符
1.Filter()
过滤指定条件的事件
Observable.just(1, 2, 3, 4, 5)
.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer > 3;
}
// a. 返回true,则继续发送
// b. 返回false,则不发送(即过滤)
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@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, "对onComplete事件作出响应");
}
});
2.ofType()
过滤特定类型的数据
Observable.just(1, "hello", 3, "world", 5)
.ofType(String.class) // 筛选出 整型数据
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "过滤后得到的事件是:" + s);
}
});
3.skip()/skipLast()
跳过某个事件
Observable.just(1, 2, 3, 4, 5)
.skip(2) // 跳过正序前两项
.skipLast(2) // 跳过倒序后两项
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤后得到的事件是:" + integer);
}
});
4.distinct() / distinctUntilChange()
过滤重复/连续重复事件
Observable.just(1, 3, 4, 4, 3, 2)
.distinct()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤重复的事件:" + integer);
}
});
执行结果: 1 3 4 2
Observable.just(1, 3, 4, 4, 3, 3, 2, 5, 5)
.distinctUntilChanged()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤连续重复的事件:" + integer);
}
});
执行结果: 1 3 4 3 2 5
事件数量过滤
1.take()
指定观察者最多能接收到的事件数量
Observable.just(1, 2, 3, 4, 5)
.take(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤连续得到的事件:" + integer);
}
});
2.takeLast()
指定观察者接收最后几个事件
Observable.just(1, 2, 3, 4, 5)
.takeLast(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "过滤连续得到的事件:" + integer);
}
});
指定时间过滤
1.throttleFirst()/throttleLast()
某段时间只接收观察者第一个/最后一个事件
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
Thread.sleep(500);
emitter.onNext(4);
Thread.sleep(1000);
emitter.onNext(2);
Thread.sleep(500);
emitter.onNext(3);
Thread.sleep(500);
}
}).throttleFirst(2, TimeUnit.SECONDS)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "throttleFirst过滤连续得到的事件:" + integer);
}
});
执行结果 1 3
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
Thread.sleep(500);
emitter.onNext(4);
Thread.sleep(1000);
emitter.onNext(2);
Thread.sleep(500);
emitter.onNext(3);
Thread.sleep(500);
}
}).throttleLast(2, TimeUnit.SECONDS)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "throttleLast过滤连续得到的事件:" + integer);
}
});
执行结果 2 3
2.sample()
发送该段事件最后一次事件 和throttleLast类似
3.throttleWithTimeOut() / debounce()
发送数据事件时 若两次发送的事件时间间隔<小于指定时间 就会丢弃前一次的数据 直到指定时间间隔没有发送新数据时才发送最后一次数据。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1); // 1、4发送事件小于1s 1 抛弃
Thread.sleep(500);
emitter.onNext(4);// 发送事件间隔>1s 发送4 然后2 、3发送<1s 2抛弃
Thread.sleep(1500);
emitter.onNext(2);// 最后发送3
Thread.sleep(500);
emitter.onNext(3);
}
}).throttleWithTimeout(1, TimeUnit.SECONDS)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "throttleWithTimeout过滤连续得到的事件:" + integer);
}
});
执行结果:4 3
事件位置过滤
1.firstElement/lastElement
选取第一个元素/最后一个元素
Observable.just(1, 2, 3, 5, 0)
// .firstElement()
.lastElement()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "firstElement过滤连续得到的事件:" + integer);
}
});
执行结果:firstElement() 1/lastElement() 0
2.elementAt() /elementAtOrError()
获取索引位置的元素(允许越界)/索引越界抛异常
Observable.just(1, 3, 5, 6, 8)
// .elementAt(2)
.elementAt(6, 9) // 越界后默认9
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "elementAt过滤连续得到的事件:" + integer);
}
});
执行结果: elementAt() 5/越界 9
Observable.just(1, 3, 5, 6, 8)
.elementAtOrError(6)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "elementAt过滤连续得到的事件:" + integer);
}
});
执行结果: elementAtOrError() 抛异常
条件布尔操作符
主要包括:
1.all()
判断发送的每项数据是否都满足条件 满足 ture 不满足 false
Observable.just(1, 2, 3, 4)
.all(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
// 发送的数据都<=5 返回true
return integer <= 5;
}
}).subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean result) throws Exception {
Log.d(TAG, "result :" + result);
}
});
2.takeWhile()
判断发送的每项数据是否都满足条件 满足 发送 不满足停止发送
Observable.interval(1, TimeUnit.SECONDS)
.takeWhile(new Predicate<Long>() {
@Override
public boolean test(Long aLong) throws Exception {
// <3才开始发送数据
return (aLong < 3);
}
}).subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long aLong) {
Log.d(TAG, "收到onNext事件:" + aLong);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "收到onError事件:" + e.toString());
}
@Override
public void onComplete() {
Log.d(TAG, "收到onComplete事件");
}
});
3.skipWhile()
判断发送的每项数据是否都满足条件 不满足开始发送
Observable.interval(1,TimeUnit.SECONDS)
.skipWhile(new Predicate<Long>() {
@Override
public boolean test(Long aLong) throws Exception {
// >5才开始发送数据
return aLong<=5;
}
}).subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long aLong) {
Log.d(TAG, "收到onNext事件:" + aLong);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "收到onError事件:" + e.toString());
}
@Override
public void onComplete() {
Log.d(TAG, "收到onComplete事件");
}
});
4.takeUntil()
传人的Observable发送数据 第一个Observable停止发送数据
Observable.interval(1, TimeUnit.SECONDS)
.takeUntil(new Predicate<Long>() {
@Override
public boolean test(Long aLong) throws Exception {
// >3停止发送数据
return aLong > 3;
}
}).subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long aLong) {
Log.d(TAG, "收到onNext事件:" + aLong);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "收到onError事件:" + e.toString());
}
@Override
public void onComplete() {
Log.d(TAG, "收到onComplete事件");
}
});
5.skipUntil()
传人的Observable发送数据 第一个Observable开始发送数据
Observable.interval(1, TimeUnit.SECONDS)
// 传入的Observable发送数据,第一个Observable才发送数据
.skipUntil(Observable.interval(5,1,TimeUnit.SECONDS))
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long aLong) {
Log.d(TAG, "收到onNext事件:" + aLong);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "收到onError事件:" + e.toString());
}
@Override
public void onComplete() {
Log.d(TAG, "收到onComplete事件");
}
});
6.SequenceEqual()
判断两个Observable发送数据是否相同 相同返回true 反之false
Observable.sequenceEqual(
Observable.just(1,2,3),
Observable.just(1,2,3)
).subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean result) throws Exception {
Log.d(TAG, "result :" + result);
}
});
7.contains()
判断发送的数据包含指定数据 包含true 反之false
Observable.just(1,2,4,7)
.contains(4)
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean result) throws Exception {
Log.d(TAG, "result :" + result);
}
});
8.isEmpty()
判断发送的数据是否为空 若为空返回true 反之false
Observable.just(1, 2, 4, 7)
.isEmpty()
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean result) throws Exception {
Log.d(TAG, "result :" + result);
}
});
9.amb()
发送多个Observable,只发送先发送的Observable数据 其余丢弃
List<Observable<Integer>> observableList = new ArrayList<>();
Observable<Integer> observable1 = Observable.just(1,2,3,4);
Observable<Integer> observable2 = Observable.just(5,7,8).delay(1,TimeUnit.SECONDS);
observableList.add(observable1);
observableList.add(observable2);
Observable.amb(observableList)
.subscribe(new Consumer<Integer>() {
// 只发送先发送的数据,后发送的舍弃
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "接收的数据 :" + integer);
}
});
10.defaultIfEmpty()
在不发送next事件下,仅发送一个complete事件的前提下,发送一个默认值
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
// emitter.onNext(1);
// emitter.onNext(2);
// 只发送Complete事件
emitter.onComplete();
}
}).defaultIfEmpty(11)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.d(TAG, "收到onNext事件:" + integer);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "收到onError事件:" + e.toString());
}
@Override
public void onComplete() {
Log.d(TAG, "收到onComplete事件");
}
});
至此,RxJava所有的操作符介绍完毕了,下篇介绍这些操作符的应用场景。
Thanks:RxJava系列教程