1.concat，concatArray操作符
concat 组合多个被观察者,数量<=4
concatArray 组合多个被观察者,可以大于4
/**
* concat 组合多个被观察者,数量<=4
* concatArray 组合多个被观察者,可以大于4
*
*/
private void concatAndconcatArray(){
// Observable.
// concat(Observable.just(1,2,3),
// Observable.just(4,5,6),
// Observable.just(7,8,9),
// Observable.just(0,0,0)).subscribe(new Consumer() {
// @Override
// public void accept(Integer integer) throws Exception {
// Log.e(TAG, "accept: "+integer );
// }
// });
Observable.concatArray(Observable.just(1),
Observable.just(2),
Observable.just(3),
Observable.just(4),
Observable.just(5))
.subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: "+integer );
}
});
}
输出结果：
image.png
2.merge,mergeArray操作符
合并多个被观察者一起发送数据，合并后按时间线并行执行（并行执行）。
/**
* merge操作符 被观察者<=4
* mergeArray操作符 被观察者可以大于4
* 合并多个被观察者一起发送数据。
* 合并后按时间线并行执行
*/
private void mergeAndmergeArray(){
// long start,开始的数字
// long count, 一共发送多少次
// long initialDelay,延迟多久发送第一次
// long period,每次发送需要的时间数量
// TimeUnit unit，每次发送需要的时间单位
Observable.merge(Observable.intervalRange(0,8,1,2, TimeUnit.SECONDS),
Observable.intervalRange(2,10,1,2,TimeUnit.SECONDS)).subscribe(new Consumer() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, "accept: "+ aLong);
}
});
//mergeArra用法一样
}
输出结果：
image.png
3.concatDelayError和mergeDelayError操作符
使用concat或者merge操作符的时候，可能某个被观察者发送事件的时候，会报错，触发onError 从而导致其他的被观察者被终止， 那么concatDelayError和mergeDelayError操作符就能解决该问题，使得所有的被观察者事件都发送结束后才触发onError。
/**
* 使用concat和merge操作符的时候，可能某个被观察者发送事件的时候， 会报错，触发onError
* 从而导致其他的被观察者被终止
* 那么concatDelayError和mergeDelayError操作符就能解决该问题，
* 使得所有的被观察者事件都发送结束后才触发onError
*/
private void concatDelayErrorAndmergeDelayError(){
Observable.concatArrayDelayError(Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext(7);
e.onError(new NullPointerException());
e.onNext(8);
}
}),Observable.just(1,2,3),Observable.just(4,5,6)).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: "+integer );
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: "+e.getMessage() );
}
@Override
public void onComplete() {
}
});
}
输出结果：
image.png
4.zip 操作符
zip操作符
该类型的操作符主要是对多个被观察者中的事件进行合并处理。
合并 多个被观察者（Observable）发送的事件，
生成一个新的事件序列（即组合过后的事件序列），并最终发送
1.事件组合方式 = 严格按照原先事件序列 进行对位合并
2.最终合并的事件数量 = 多个被观察者（Observable）中数量最少的数量
/**
* zip操作符
* 该类型的操作符主要是对多个被观察者中的事件进行合并处理。
* 合并 多个被观察者（Observable）发送的事件，
* 生成一个新的事件序列（即组合过后的事件序列），并最终发送
* 1.事件组合方式 = 严格按照原先事件序列 进行对位合并
* 2.最终合并的事件数量 = 多个被观察者（Observable）中数量最少的数量
*/
private void zip(){
Observable observable1 = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).subscribeOn(Schedulers.io());//起一个新的线程工作
Observable observable2 = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext(9);
e.onNext(8);
e.onNext(7);
e.onNext(6);
}
}).subscribeOn(Schedulers.newThread());//起一个新的线程工作
//合并并对事件转换
Observable.zip(observable1, observable2, new BiFunction() {
@Override
public String apply(Integer integer, Integer integer2) throws Exception {
return integer+":"+integer2;
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String integer) {
Log.e(TAG, "合并后的事件: "+integer );
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
输出结果：
image.png
5.comebineLatest操作符
第一个被观察者的最后一个事件和第二个被观察者的每一个事件合并，与zip不同的是 zip是两个被观察者对应位置的事件合并
/**combineLatest操作符
* 第一个被观察者的最后一个事件
* 和第二个被观察者的每一个事件合并
* 与zip不同的是 zip是两个被观察者对应位置的事件合并
*
*/
private void comebineLatest(){
Observable observable1 =Observable.just(1,2,3,4,5);
Observable observable2 = Observable.just(2,2,3,4);
Observable.combineLatest(observable1, observable2, new BiFunction() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
//合并逻辑
return integer+integer2;
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: "+integer );
}
});
}
输出结果：
image.png
6.reduce 操作符
把被观察者需要发送的事件聚合成1个事件 & 发送合并逻辑自己写。总之就是前两个的合并结果和后一个事件合并。
/**
* 把被观察者需要发送的事件聚合成1个事件 & 发送
* 合并逻辑自己写。
* 总之就是前两个的合并结果和后一个事件合并
*
*/
private void reduce(){
Observable.just(1,2,3,4).reduce(new BiFunction() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
Log.e(TAG, "apply: "+integer+"乘以"+integer2);
return integer*integer2;
}
}).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: "+integer );
}
});
}
输出结果：
image.png
7.collect操作符
将被观察者Observable发送的数据事件收集到一个数据结构里
/**
* 将被观察者Observable发送的数据事件收集到一个数据结构里
*/
private void collect(){
Observable.just(1,2,3,4,5).collect(new Callable>() {
@Override
public ArrayList call() throws Exception {
return new ArrayList<>();
}
}, new BiConsumer, Integer>() {
@Override
public void accept(ArrayList integers, Integer integer) throws Exception {
integers.add(integer);
}
}).subscribe(new Consumer>() {
@Override
public void accept(ArrayList integers) throws Exception {
Log.e(TAG, "accept: "+integers.toString() );
}
});
}
输出结果：
image.png
7.startWith 操作符
1.在一个被观察者发送事件前追加事件(在前面追加)
2.在一个被观察者发送事件前追加被观察者(在前面追加)
/**
* 1.在一个被观察者发送事件前追加事件(在前面追加)
* 2.在一个被观察者发送事件前追加被观察者(在前面追加)
*/
private void startWith (){
Observable.just(1,2,3).startWith(5).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: "+integer );
}
});
Observable.just(7,8).startWith(Observable.just(9,10)).subscribe(new Consumer() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: "+integer );
}
});
}
8.count操作符
统计被观察者发送事件的数量
private void count(){
Observable.just(1,2,3).count().subscribe(new Consumer() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, "accept: "+aLong );
}
});
}