本篇文章总结了Rxjava2中的各种操作符以及对应的例子
参考视频:https://edu.csdn.net/course/play/10036/215978
目录
defer等到订阅的时候,才会发射事件流,会随最新的数据变化
range发射一个范围内的整数数据流,范围为n 到 n+m-1
flatmap类型转换,返回的是包含结果集的Observable,即包装成另一个数据流,即多重转换
groupBy操作符将发射出来的数据项进行分组,并将分组后的数据项保存在key-value映射的事件流中
scan会对发射的数据和上一轮发射的数据进行函数处理,并返回数据提供给下一轮使用
buffer:对发射出来的数据进行一定数量的缓存,然后分组发射,发射出来的是新的数据流
window:也是缓存作用,和buffer不同的是window操作符发出的是一个新的事件流,即新的事件流中的数据项还可以经过其他操作符进行处理.
debounce:过滤掉发射速率过快的数据项,如网络请求,在一段时间内只取最后一次操作
ignoreElements() :忽略元素只处理最后的onComplete()方法
zip:将两个数据流按照指定的函数规则合并为一个数据流,一同发出
startWith将另一个数据流合并到原数据流的开头,一同发出
combineLastest会寻找其他事件流最近发射的数据流进行合并然后一同发出
onErrorReturn当错误发生时,会忽略onError的回调且会发射一个新的数据项并回调onCompleted()
onErrorResumeNext表示当错误发生时,会忽略onError的回调且会发射一个新的事件流并回调onCompleted()
onExceptionResumeNext表示收到的是Exception,会回调备用的事件流进行数据的发射;
如果不是一个Exception,如注释的Error,会回调onError方法
retry表示当错误发生时,发射器会重新发射,参数决定重新几次
retryWhen:与retry类似,区别在于retryWhen将Throwable传递给了函数进行处理并产生新的事件流进行处理
materialize/dematerialize:对事件流进行装箱/解箱
serialize:可以将异步执行的事件流进行同步操作,直到事件流结束,应该用到多线程
timeInterval:将发射的数据项转换为带有时间间隔的数据项,就是将事件间隔包装为一个对象进行发射
timeout:当发射的数据项超过了规定的时间,则发射onError事件
Using:可以让你的事件流存在一次性的数据项,即用完就将资源释放掉
all:所有的数据项都满足条件则为true,否则返回false
skipUtils:两个事件流发射的时候,第一个事件流会等到第二个事件流发射的时候,第一个事件流才开始发射数据
skipWhile:在一个事件中,判断是否符合某个特定条件,如果符合,则不发射,如果不符合则终止判断,发射剩余的所有数据
takeUtils:第一个事件流会发射到第二个事件流发射的时候停止发射
reduce:和scan操作符一样,会对发射的数据和上一轮的数据进行函数处理,并返回数据供下一轮使用,会输出最后的结果
collect:和reduce类似,还可以改变数据结构,如下就把Interger改为了String类型
publish + connect:publish把事件流转换为可连接的事件流,connect把可连接的事件流去连接,连接之后数据才会发射出来
replay操作符弥补了connect操作符的缺陷,可以将发射出去的操作符进行缓存,不会丢失发射出去的数据项
依赖
implementation 'io.reactivex.rxjava2:rxjava:2.2.6'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
创建操作符
create :创建操作符,创建最简单的事件流
其中Consumer为自定义观察者方法,不必全部实现观察者所有方法,此accept对应onNext()方法
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
for (int i = 0; i < 5; i++) {
emitter.onNext(i);
}
emitter.onComplete();
}
})
.observeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer);
}
});
from把一个团分开,然后分别发射
Observable.fromArray(1,2,3,4,5)
.observeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "onNext: " + integer);
}
});
just直接发射当前的数据流,可发送多个参数,最多10个
Observable.just(1,2,3,4,5)
.observeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "onNext: " + integer);
}
});
defer等到订阅的时候,才会发射事件流,会随最新的数据变化
i = 10;
Observable<Integer> just = Observable.just(i);
Observable<Object> defer = Observable.defer(new Callable<ObservableSource<?>>() {
@Override
public ObservableSource<?> call() throws Exception {
return Observable.just(i);
}
});
i = 15;
just.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "just: " + integer );
}
});
defer.subscribe(new Consumer<Object>() {
@Override
public void accept(Object o) throws Exception {
Log.e(TAG, "defer: " + o );
}
});
输出
interval 每隔一段时间发射一次,一直重复
Observable.interval(1, TimeUnit.SECONDS)
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, "accept: " + aLong );
}
});
range发射一个范围内的整数数据流,范围为n 到 n+m-1
Observable.range(2, 5)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});
repeat重复几次
Observable.just(1).repeat(6)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: "+(count++) +integer);
}
});
Timer延时几秒去发射,只发射一次
Observable.timer(2,TimeUnit.SECONDS)
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, "accept: "+aLong );
}
});
转换操作符
map对数据流进行类型转换
Observable.just(1).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "变为了字符串"+integer;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "accept: "+s );
}
});
flatmap类型转换,返回的是包含结果集的Observable,即包装成另一个数据流,即多重转换
Observable.just(new User("Tian",22)).flatMap(new Function<User, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(User user) throws Exception {
return Observable.just(user.getName() + "登录成功");
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "accept: " + s);
}
});
class User{
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
map和flatMap的区别:
Map返回的是结果集,flatMap返回的是包含结果集的Observable
FlatMap可用于一对多,多对多,
flatMap和concatMap的区别
两者的用法相同,flatMap是乱序的,concatMap的有序的
groupBy操作符将发射出来的数据项进行分组,并将分组后的数据项保存在key-value映射的事件流中
Observable.just("java", "c", "kotlin", "c++", "Android", "javascript")
.groupBy(new Function<String, Character>() {
@Override
public Character apply(String s) throws Exception {
//按首字母排序
return s.charAt(0);
}
})
.subscribe(new Consumer<GroupedObservable<Character, String>>() {
@Override
public void accept(final GroupedObservable<Character, String> characterStringGroupedObservable) throws Exception {
characterStringGroupedObservable.sorted().subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "accept: "+characterStringGroupedObservable.getKey() + " "+s );
}
});
}
})
scan会对发射的数据和上一轮发射的数据进行函数处理,并返回数据提供给下一轮使用
Observable.just(8,2,5,10,15).scan(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
return integer > integer2 ? integer : integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});
buffer:对发射出来的数据进行一定数量的缓存,然后分组发射,发射出来的是新的数据流
Observable.just(8,2,5,10,15).buffer(2)
.subscribe(new Consumer<List<Integer>>() {
@Override
public void accept(List<Integer> integers) throws Exception {
Log.e(TAG, "accept: "+integers.toString() );
}
});
window:也是缓存作用,和buffer不同的是window操作符发出的是一个新的事件流,即新的事件流中的数据项还可以经过其他操作符进行处理.
window(2,1)代表缓存两个,然后输出,跳1个,继续缓存
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9).window(2, 1)
.subscribe(new Consumer<Observable<Integer>>() {
@Override
public void accept(Observable<Integer> integerObservable) throws Exception {
integerObservable.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer);
}
});
}
});
部分结果:
过滤操作符
debounce:过滤掉发射速率过快的数据项,如网络请求,在一段时间内只取最后一次操作
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
for (int i = 0; i < 5; i++) {
if (i % 3 == 0) {
Log.e(TAG, "subscribe: " + i);
Thread.sleep(3000);
} else {
//Log.e(TAG, "subscribe: " + i );
Thread.sleep(1000);
}
emitter.onNext(i);
}
}
}).debounce(2000, TimeUnit.MILLISECONDS)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer);
}
});
从0开始,睡眠了3秒,超过了2秒,所以不接受,到1睡眠一秒,到2睡眠1秒,这时两秒间隔之内2在后,所以接收了2,同理后面的接收了4
distinct过滤重复发射的数据项
Observable.just(1, 2, 3, 1, 2, 4).distinct()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer);
}
});
elementAt() 输出下标为几的数据
Observable.just(1, 2, 3, 1, 2, 4).elementAt(2).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});
filter过滤出满足条件的值
Observable.just(1, 2, 3, 1, 2, 4).filter(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.e(TAG, "accept: " + integer );
}
});
first():输出第一项的数据,参数为默认值
Observable.just(1, 2, 3, 1, 2, 4).first(0)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});
ignoreElements() :忽略元素只处理最后的onComplete()方法
Observable.just(1, 2, 3, 1, 2, 4).ignoreElements()
.subscribe(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "onComplete: ");
}
});