一、概述
RxJava2在第一篇文章中基本用法作了详细的介绍,是一个基于事件流的异步操作库。相信大家对RxJava有了一定的理解,由于篇幅过长所以重新写了一篇,如果不了解Rxjava2可以参考下RxJava2最全面、最详细的讲解(一)。下面开始继续讲解RxJava2的其他用法。(源码和其他链接在文章最后给出)
在使用前记得在build.gradle文件中添加依赖:
implementation 'io.reactivex.rxjava2:rxjava:2.0.4'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
注意:RxJava1与RxJava2依赖不能共存。不能同时添加RxJava1与RxJava2的依赖,只能添加其中一个。
RxJava的操作符就是java中的用法,详尽的操作符请看官网ReactiveX的官方网站,这里列举了一部分:
Creating Observables(Observable的创建操作符),比如:Observable.create()、Observable.just()、Observable.from()等等;
Transforming Observables(Observable的转换操作符),比如:observable.map()、observable.flatMap()、observable.buffer()等等;
Filtering Observables(Observable的过滤操作符),比如:observable.filter()、observable.sample()、observable.take()等等;
Combining Observables(Observable的组合操作符),比如:observable.join()、observable.merge()、observable.combineLatest()等等;
Error Handling Operators(Observable的错误处理操作符),比如:observable.onErrorResumeNext()、observable.retry()等等;
Observable Utility Operators(Observable的功能性操作符),比如:observable.subscribeOn()、observable.observeOn()、observable.delay()等等;
Conditional and Boolean Operators(Observable的条件操作符),比如:observable.amb()、observable.contains()、observable.skipUntil()等等;
Mathematical and Aggregate Operators(Observable数学运算及聚合操作符),比如:observable.count()、observable.reduce()、observable.concat()等等;
其他如observable.toList()、observable.connect()、observable.publish()等等;
二、变换操作符
变换操作符的主要是对事件序列中的事件进行处理变换,使其转变成不同的事件,再加以处理。这里列举几种常用的操作符
1.Map()
map操作符把被观察者Observable产生的结果通过映射规则转换成另一种结果集,并交给订阅者处理。简单来说就是对被观察者发送的每个事件都通过指定函数的处理,从而转变成另一种事件。
//链式编程
Observable.just(1, 2, 3, 4, 5)
//使用Map操作符中的Function函数对被观察者发送的事件统一作出处理
.map(new Function<Integer, Integer>() {
@Override
public Integer apply(Integer integer) throws Exception {
//对被观察者just发送的结果,都全部乘以10处理
return integer * 10;
}
}).subscribe(new Consumer<Integer>() {//订阅
@Override
public void accept(Integer integer) throws Exception {//接受事件结果,是处理后的结果
Log.e(TAG, "map:accept == " + integer);
}
});
上面的例子中我们使用just()操作符连续发送1,2,3,4,5等5个事件,通过Map操作符中的Function函数对被观察者发送的事件统一作出乘以10处理,订阅后输出最终结果:
2.flatMap()
flatMap()操作符是将Observable(被观察者)产生的结果拆分和单独转换变成多个Observable,然后把多个Observable“扁平化”整合成新的一个Observable,并依次提交产生的结果给订阅者。
大意为:flatMap()通过传入一个函数作为参数转换源Observable(被观察者),在这个函数中你可以自定义转换规则,最后在这个函数中返回一个新的Observable,然后flatMap函数回调方法通过合并这些Observable成一个新的Observable,发送给Observer(观察者)。(理论比较抽象,我们来看例子)
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) {
e.onNext("A");
e.onNext("B");
e.onComplete();
}
}).flatMap(new Function<String, ObservableSource<String>>() {
@Override//通过flatMap将被观察者生产的事件进行拆分,再将新的事件转换成一个新的Observable发送
public ObservableSource<String> apply(String s) {
List<String> list = new ArrayList<>();
Log.e(TAG, "flatMap:apply == 事件" + s);
//将一个事件拆分成两个子事件,例如将A事件拆分成A0,A1两个事件,然后再整个合成一个Observable通过fromIterable发送给订阅者
for (int j = 0; j < 2; j++) {
list.add("拆分后的子事件" + s + j);
}
return Observable.fromIterable(list);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) {
Log.e(TAG, "flatMap:accept == " + s);
}
});
上面我们发送了A、B两个事件,在flatMap中接收到A事件后,将A事件拆分成A0,A1两个事件,再通过fromIterable(list)整合成一个Observable发送给订阅者。打印log如下:
注意:flatMap在合并Observable结果时,可能存在交叉的情况出现,即新合并生成的序列可能是无序的。(上面的例子我演示多次并没有出现乱序)
3.concatMap()
concatMap()和flatMap()方法类似,都是把Observable(被观察者)产生的事件转换成多个Observable(被观察者),然后把Observable整合成一个Observable,并依次提交生产的结果给订阅者。
与flatMap()不同的是,concatMap()在处理产生的Observable时,采用的是“连接concat”的方式,而不是“marge合并”的方式,这样就保证了产生事件的顺序性,也就是说提交给订阅者的结果是按照顺序提交的,不会存在交叉的可能性。
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) {
e.onNext("A");
e.onNext("B");
e.onComplete();
}
}).concatMap(new Function<String, ObservableSource<String>>() {
@Override//通过concatMap(有序)将被观察者生产的事件进行拆分,再将新的事件转换成一个新的Observable发送
public ObservableSource<String> apply(String s) {
List<String> strings = new ArrayList<>();
Log.e(TAG, "concatMap:apply == 事件" + s);
for (int j = 0; j < 2; j++) {
strings.add("拆分后的子事件" + s + j);
}
return Observable.fromIterable(strings);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) {
Log.e(TAG, "concatMap:accept == " + s);
}
});
打印的log如下:
4.buffer()
buffer()操作符将Observable(被观察者)需要发送的事件周期性收集到列表中,并把这列表提交给Observer(观察者),观察者处理后,清空buffer列表,同时接收下一次的结果交给订阅者,周而复始。
需要注意的是:一但初始的Observable在产生事件中出现异常,即使buffer()收集到已经存在的结果,订阅者也会马上收到这个异常,并结束整个过程。
Observable.just("A", "B", "C", "D", "E")//这里演示发送5个事件
.buffer(3, 2)//缓存列表数量为3个,步长为2
.subscribe(new Observer<List<String>>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "buffer:onSubscribe == 订阅");
}
@Override
public void onNext(List<String> strings) {
Log.e(TAG, "buffer:onNext == 缓存事件数:" + strings.size());
for (int j = 0; j < strings.size(); j++) {
Log.e(TAG, "buffer:子事件==" + strings.get(j));
}
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "buffer:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "buffer:onComplete == ");
}
});
上述例子设置了"ABCDE"5个事件,缓存事件数为3个,步长为2。在被观察者的事件中,第一次获取3个事件数放到缓存区域,即"A","B","C",发送给订阅者;第二次获取时,因为步长=2,所以事件往后移动2个,即指针往后移动2位,从"C"开始取三个事件,即"C","D","E"发送给订阅者;第三次获取时,事件再在第二次的基础上往后移动2个,即到了"E",取3个事件,事件不足3个,只能够取"E"发送给订阅者。看图比较好理解,我们来看看buffer()的原理图:
打印结果如下:
这里先对变换操作符做出表格总结:
创建类型 | 作用 | 使用场景 | |
---|---|---|---|
变换操作符 | map() | 对Observable发送的每一个事件进行转换 | 数据类型、事件等需要转换 |
flatMap() | 对Observable发送的整个个事件进行转换(无序) | ||
concatMap() | 对Observable发送的整个个事件进行转换(有序) | ||
buffer() | 从Observable的事件中获取事件放到缓存区再发送事件 |
三、组合操作符
1.concat()与concatArray()
concat()与concatArray()都是组合多个被观察者的一起发送数据,合并后安先后顺序执行。
二者的区别是:concat()的观察者数量最多是4个,而concatArray()的个数没有限制
//concat的构造方法
concat(source1);
concat(source1, source2);
concat(source1, source2, source3);
concat(source1, source2, source3, source4);
//concatArray的构造方法
concatArray(ObservableSource<? extends T>... sources);
我们来看看简单的运用:
Observable.concat(Observable.just(1, 2), Observable.just(3, 4), Observable.just(5, 6), Observable.just(7, 8))
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "concat:onSubscribe == 订阅");
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "concat:onNext ==" + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "concat:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "concat:onComplete == ");
}
});
Observable.concatArray(Observable.just("一", "二"), Observable.just("三", "四"),
Observable.just("五", "六"), Observable.just("七", "八"), Observable.just("九", "十"))
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "concatArray:onSubscribe == 订阅");
}
@Override
public void onNext(String s) {
Log.e(TAG, "concatArray:onNext ==" + s);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "concatArray:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "concatArray:onComplete == ");
}
});
上面concat()创建了四个被观察者,发送1,2,3,4,5,6,7,8个事件,concatArray()创建了五个被观察者,发送一,二,三,四,五,六,七,八,九,十,打印log如下:
2.Merge()与MergeArray()
Merge()与MergeArray()组合多个被观察者发送数据,按照时间先后顺序来执行。与concat()与concatArray()组合类似
Merge()与MergeArray()的区别:Merge()只能发送最多4个Observable(被观察者),MergeArray()的数量没有限制。MergeArray()这里就不演示例子了。
Megre()的构造方法:
merge(source1);
merge(source1, source2);
merge(source1, source2, source3);
merge(source1, source2, source3, source4);
MergeArray()的构造方法:
mergeArray(ObservableSource<? extends T>... sources);
//起始值为1,发送3个事件,第一个事件延迟1秒发送,事件间隔为1秒
Observable<Long> observable1 = Observable.intervalRange(1, 3, 1, 1, TimeUnit.SECONDS);
//起始值为10,发送3个事件,第一个事件延迟1秒发送,事件间隔为1秒
Observable<Long> observable2 = Observable.intervalRange(10, 3, 1, 1, TimeUnit.SECONDS);
Observable.merge(observable1, observable2)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "concatArray:onSubscribe == 订阅");
}
@Override
public void onNext(Long aLong) {
Log.e(TAG, "concatArray:onNext ==" + aLong);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "concatArray:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "concatArray:onComplete == ");
}
});
这里我们创建了两个被观察者,一个起始值为1,延迟1秒发送3个事件,另一个为起始值为10,延迟1秒发送3个事件,按照Observable提交结果的时间顺序来执行,对Observable进行合并,Observable1每隔1秒产生数据为:1,2,3,Observable2每隔1秒产生的数据为:10,11,12,都延迟1秒产生,最后合并的结果为:1,10,2,11,3,12,MergeArray()同理,打印log如下:
可以看出都是按照时间的先后顺序来执行被观察者发送事件。
3.concatDelayError()
concat()与concatArray()组合中,如果某一个Observable(被观察者)发出onError()事件,则会马上停止其他事件的发送。如果需要onError()事件推迟到其他事件发送完成才出发的话则需要用到concatDelayError()方法;
我们来看看concat()方法中途抛出异常的例子:
Observable<String> observable1 = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
e.onNext("第一个事件");
e.onNext("第二个事件");
e.onError(new Exception("中途抛出异常"));
e.onComplete();
}
});
Observable<String> observable2 = Observable.just("第三个事件");
//中途抛出异常列子:
Observable.concat(observable1, observable2).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "concatDelayError:onSubscribe == 订阅");
}
@Override
public void onNext(String s) {
Log.e(TAG, "concatDelayError:onNext ==" + s);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "concatDelayError:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "concatDelayError:onComplete == ");
}
});
这里我们依次发送第一个事件,第二个事件,中途抛出异常,调用onComplete(),第三个事件,打印log如下:
可以看到,调用onError()方法以后,其他事件概不执行了,那么我们来看看解决办法,改用concatDelayError():
Observable<String> observable1 = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
e.onNext("第一个事件");
e.onNext("第二个事件");
e.onError(new Exception("中途抛出异常"));
e.onComplete();
}
});
Observable<String> observable2 = Observable.just("第三个事件");
//中途抛出异常列子:
Observable.concatArrayDelayError(observable1, observable2).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "concatDelayError:onSubscribe == 订阅");
}
@Override
public void onNext(String s) {
Log.e(TAG, "concatDelayError:onNext ==" + s);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "concatDelayError:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "concatDelayError:onComplete == ");
}
});
会把错误在所有结果合并完后才执行,打印的数据如下:
4.megreDelayError()
megreDelayError()方法同上,meger()合并的某个Observable(被观察者)出现异常,会马上停止合并,并对订阅者回到onError()方法,而megreDelayError()会把错误在所有结果合并完后才执行:
//创建被观察者-异常
Observable<Object> errorObservable = Observable.error(new Exception("抛出异常"));
//产生0,2,4的事件序列,每隔1秒发送事件,一共发送3次
Observable<Object> observable1 = Observable.interval(0, 1, TimeUnit.SECONDS)
.map(new Function<Long, Object>() {
@Override
public Object apply(Long aLong) throws Exception {
return aLong * 2;
}
}).take(3)/*.mergeWith(errorObservable.delay(4, TimeUnit.SECONDS))*/;
//产生0,10,20的事件序列,每隔1秒发送事件,一共发送3次,
Observable<Long> observable2 = Observable.interval(1, 1, TimeUnit.SECONDS)
.map(new Function<Long, Long>() {
@Override
public Long apply(Long aLong) throws Exception {
return aLong * 10;
}
}).take(3);
Observable.mergeDelayError(observable1, errorObservable, observable2)
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "mergeDelayError:onSubscribe == 订阅");
}
@Override
public void onNext(Object o) {
Log.e(TAG, "mergeDelayError:onNext ==" + o);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "mergeDelayError:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "mergeDelayError:onComplete == ");
}
});
打印效果如下:
5.startWith()与startWithArray()
startWith()与startWithArray()操作符都是在源Observable(被观察者)提交结果之前,插入指定的某些数据,注意调用顺序:先调用最后加入的数据。
startWith()的构造方法:
//传入单个数据
startWith(T item)
//传入集合,可将数据加入一个集合中
startWith(Iterable<? extends T> items)
startWithArray()的构造方法:
//可传入多个参数,可变长参数
startWithArray(T... items)
ArrayList<String> strings = new ArrayList<>();
strings.add("Array:1");
Observable.just("一", "二", "三", "四")
.startWith(strings)//插入单个集合
.startWith("startWith:2")//插入单个数据
.startWithArray("startWithArray:3", "startWithArray:4")//插入多个数据
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "startWith:onSubscribe == 订阅");
}
@Override
public void onNext(String s) {
Log.e(TAG, "startWith:onNext 结果== " + s);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "startWith:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "startWith:onComplete == ");
}
});
上面例子中,在just()的前面依次加入的是:集合[Array:1],“startWith:2”,"startWithArray:3", "startWithArray:4",但是打印出来的结果顺序却刚好相反,说明Observable优先发送最后插入的数据,log如下:
组合操作符简单总结一下:
创建类型 | 作用 | 备注 | 使用场景 | |
---|---|---|---|---|
组合操作符 | concat()与concatArray() | 组合多个被观察者发送数据,合并后按照顺序执行 | 区别:组合被观察者数量: concat()<=4,concatArray()无限制 | 合并数据源 联合处理 |
Merge()与MergeArray() | 组合多个被观察者发送数据,合并后按照时间顺序执行 | 区别:组合被观察者数量: Merge()<=4,MergeArray()无限制 | ||
concatDelayError() | 将错误事件延迟到所以事件执行完后才执行错误事件 | |||
megreDelayError() | ||||
startWith()与startWithArray() | 在一个被观察者发送数据前,追加发送一些数据 | 调用顺序:先追加的后调用,后追加的先调用 |
四、合并操作符
1.zip()
zip()是把两个Observable(被观察者)提交的结果,严格按照顺序对位进行合并,最后发送给订阅者,最终合并的数量等于多个Observable数量最少的数量。
注意:下面的Observable1中的4并没有事件与其合并打印出来,但是事件还是会发送的。
//设置需要传入的被观察者数据
Observable<Integer> observable1 = Observable.just(1, 2, 3, 4);
Observable<String> observable2 = Observable.just("A", "B", "C");
//回调apply()方法,并在里面自定义合并结果的逻辑
// BiFunction<Integer, String, String>,第一个类型为observable1的参数类型,第二个类型为observable2的参数类型,第三个为合并后的参数类型
Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
@Override
public String apply(Integer integer, String str) throws Exception {
return integer + str;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "zip:onSubscribe == 订阅");
}
@Override
public void onNext(String s) {
Log.e(TAG, "zip:onNext == " + s);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "zip:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "zip:onComplete == ");
}
});
上面根据顺序的对位合并数据为:1A,2B,3C,4没有与其合并的事件,打印log如下:
2.combineLatest()
combineLatest()是将两个Observable(被观察者)产生的结果进行合并,合并的结果将组成一个新的Observable发送给订阅者。这两个Observable中任意的一个Observable产生的结果,都与另一个Observable最后的结果,按照一定的规则进行合并。
与zip()类似,区别在于zip()根据个数1对1合并,combineLatest()根据时间点一对一合并。
//产生0,10,20的事件序列,每隔1秒发送事件,一共发送3次
Observable<Long> observable1 = Observable.interval(0, 1, TimeUnit.SECONDS)
.map(new Function<Long, Long>() {
@Override
public Long apply(Long aLong) throws Exception {
return aLong * 10;
}
}).take(3);
//产生0,1,2,3,4的事件序列,起始值为0,一共发送4次,延迟1秒后开始发送,每隔1秒发送事件
Observable<Long> observable2 = Observable.intervalRange(0, 4, 1, 1, TimeUnit.SECONDS)
.map(new Function<Long, Long>() {
@Override
public Long apply(Long aLong) throws Exception {
return aLong * 1;
}
});
Observable.combineLatest(observable1, observable2, new BiFunction<Long, Long, Long>() {
@Override
public Long apply(Long o1, Long o2) throws Exception {
Log.e(TAG, "combineLatest:apply: o1+o2:" + o1 + "+" + o2);
//observable1的最后的一个数据都与observable2的每一个数据相加
return o1 + o2;
}
}).subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "combineLatest:onSubscribe == 订阅");
}
@Override
public void onNext(Long aLong) {
Log.e(TAG, "combineLatest:onNext 合并的结果== " + aLong);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "combineLatest:onError == " + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "combineLatest:onComplete == ");
}
});
Observable1的事件序列为0,10,20;Observable2的事件序列为0,1,2,3, Observable2因为延迟了1秒发送,所以在Observable1执行1秒后即Observable1=10时,Observable2才开始执行事件,否则在Observable2未开始执行事件前,Observable2的默认值与Observable1合并事件,如果Observable1执行完事件后,以Observable1最后的值为准Observable1=20,那么合并出来的数据为:10+0,20+0,20+1,20+2,20+3,打印log如下:
3.combineLatestDelayError()
combineLatest()合并过程中一但出现异常就会立即停止后续合并事件,并且回调onError()方法,combineLatestDelayError()是把错误放到所有结果都合并完成之后才执行。
combineLatestDelayError()类似concatDelayError()、mergeDelayError(),这里就不在举例子了。
4.reduce()
reduce()把观察者需要发送的事件聚合成一个事件并且发送。本质上都是前两个数据聚合,再与后一个数据聚合,依次类推。
Observable.just(1, 2, 3, 4, 5).
reduce(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
Log.e(TAG, "reduce:accept 计算结果== " + integer + "*" + integer2);
//按先后顺序,两个事件聚合处理后 ,将结果再与下一事件聚合处理,依次类推
return integer * integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "reduce:accept 合并的结果== " + integer);
}
});
比如上面的1, 2, 3, 4, 5共5个事件,1与2聚合后生成新的Observable(被观察者),新的Observable与下一个数3再聚合,依次类推,所以数据聚合完成,打印数据如下:
5.collect()
将Observable(被观察者)发送的数据收集到一个容器中(数据结构)。Observable将事件队列分别装入一个准备好的容器中,然后在新的Observable将该容器发送给订阅者。
//第一个参数:声明容器的类型,第二个参数:处理数据的逻辑,加入容器中
Observable.just(1, 2, 3, 4, 5).collect(new Callable<ArrayList<Integer>>() {
@Override
public ArrayList<Integer> call() throws Exception {
return new ArrayList<>();
}
}, new BiConsumer<ArrayList<Integer>, Integer>() {
@Override
public void accept(ArrayList<Integer> list, Integer integer) throws Exception {
Log.e(TAG, "reduce:collect 加入容器的数据== " + integer);
list.add(integer);
}
}).subscribe(new Consumer<ArrayList<Integer>>() {
@Override
public void accept(ArrayList<Integer> integers) throws Exception {
Log.e(TAG, "reduce:collect 最后结果== " + integers);
}
});
Callable方法声明一个容器,Callable实现的方法将数据加入容器中,打印数据如下:
合并操作符的简单总结:
创建类型 | 作用 | 备注 | 使用场景 | |
---|---|---|---|---|
合并操作符 | zip() | 合并多个被观察者发送的事件,生成一个新的事件序列。 | 严格按照事件序列进行合并 最后Observable的数据=多个Observable中数量最少的 | 合并数据源 联合处理 |
combineLatest() | 将两个Observable产生的结果进行合并,合并新的Observable发送给订阅者 | 当其中一个Observable发送数据,都与另一个Observable最后发送的数据结合,类似zip(),不同的是按照时间点合并 | ||
combineLatestDelayError() | 将错误事件延迟到所以事件执行完后才执行错误事件 | |||
reduce() | 把观察者需要发送的事件聚合成一个事件并且发送。 | 前两个被观察者聚合成新的被观察者,再与下一数据聚合,一次类推 | ||
collect() | 将被观察者发送的数据放到一个容器中处理 |
五、统计发送事件的数量
1.count()
count()方法是统计Observable(被观察者)发送的事件的数量。
Observable.just(1, 2, 3, 4, 5)
.count()
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long l) throws Exception {
Log.e(TAG, "reduce:accept 事件数== " + l);
}
});
这个方法比较简单,just()发送了1, 2, 3, 4, 5共5个事件,打印log如下: