本章节讲述RxJava基于2.X版本的组合操作符
1.concat()&concatArray()
<1> 作用
组合多个被观察者一起发送数据，合并后 按 发送顺序串行 执行。
源码
public static <T> Observable<T> concat(
ObservableSource<? extends T> source1, ObservableSource<? extends T> source2,
ObservableSource<? extends T> source3, ObservableSource<? extends T> source4) {
return concatArray(source1, source2, source3, source4);
}也就是说 concat() 方法中调用了concatArray()方法。且 concat() 方法最多只能接收4个参数。超过4个的被观察者合并可以使用concatArray()方法。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import java.io.Serializable;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava concat组合符
*/
public void method() {
Observable.concat(
Observable.just(1, 2, "张三"),
Observable.just(4, 5, "李四"),
Observable.just("小马", "小红", 12.87),
Observable.create(new ObservableOnSubscribe<Serializable>() {
@Override
public void subscribe(ObservableEmitter<Serializable> e) throws Exception {
if (null == e) {
return;
}
if (!e.isDisposed()) {
e.onNext("create操作符发送消息");
e.onComplete();
}
}
}))
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接：" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果：" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----：" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接：false
D/TAG: 观察者 onNext方法 结果：1
D/TAG: 观察者 onNext方法 结果：2
D/TAG: 观察者 onNext方法 结果：张三
D/TAG: 观察者 onNext方法 结果：4
D/TAG: 观察者 onNext方法 结果：5
D/TAG: 观察者 onNext方法 结果：李四
D/TAG: 观察者 onNext方法 结果：小马
D/TAG: 观察者 onNext方法 结果：小红
D/TAG: 观察者 onNext方法 结果：12.87
D/TAG: 观察者 onNext方法 结果：create操作符发送消息
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----：false
D/TAG: onDestroy方法 断开订阅
2.concatDelayError()&concatArrayDelayError()
<1> 作用
分别对应concat()&concatArray()。区别在于组合多个被观察者中有观察者出错时的表现。concatDelayError()&concatArrayDelayError()当组合的多个被观察者有错误的时。可以继续执行下面的观察者。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import java.io.Serializable;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava concatArrayDelayError组合符
*/
public void method() {
Observable.concatArrayDelayError(
Observable.just(1, 2, "张三"),
Observable.just(4, 5, "李四"),
Observable.create(new ObservableOnSubscribe<Serializable>() {
@Override
public void subscribe(ObservableEmitter<Serializable> e) throws Exception {
if (null == e) {
return;
}
if (!e.isDisposed()) {
e.onNext("create操作符发送消息");
e.onNext(new Throwable());
e.onComplete();
}
}
}),
Observable.just("小马", "小红", 12.87))
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接：" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果：" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----：" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}错误模拟：onNext中发送错误信息，然后执行onComplete方法。
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接：false
D/TAG: 观察者 onNext方法 结果：1
D/TAG: 观察者 onNext方法 结果：2
D/TAG: 观察者 onNext方法 结果：张三
D/TAG: 观察者 onNext方法 结果：4
D/TAG: 观察者 onNext方法 结果：5
D/TAG: 观察者 onNext方法 结果：李四
D/TAG: 观察者 onNext方法 结果：create操作符发送消息
D/TAG: 观察者 onNext方法 结果：java.lang.Throwable
D/TAG: 观察者 onNext方法 结果：小马
D/TAG: 观察者 onNext方法 结果：小红
D/TAG: 观察者 onNext方法 结果：12.87
即，中间有被观察者出错，还是会继续发送下面的被观察者。
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----：false
D/TAG: onDestroy方法 断开订阅
3.merge()&mergeArray()
<1> 作用
组合多个被观察者一起发送数据，合并后 按时间线并行执行。
源码
public static <T> Observable<T> merge(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3) {
ObjectHelper.requireNonNull(source1, "source1 is null");
ObjectHelper.requireNonNull(source2, "source2 is null");
ObjectHelper.requireNonNull(source3, "source3 is null");
return fromArray(source1, source2, source3).flatMap((Function)Functions.identity(), false, 3);
}也就是说 merge()方法中调用了mergeArray()方法。且merge() 方法只能接收3个参数。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import java.util.concurrent.TimeUnit;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava merge组合符
*/
public void method() {
Observable.merge(
Observable.intervalRange(2, 3, 1, 1, TimeUnit.SECONDS),
Observable.intervalRange(1, 3, 1, 1, TimeUnit.SECONDS),
Observable.intervalRange(5, 3, 1, 1, TimeUnit.SECONDS)
).subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接：" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果：" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----：" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接：false
D/TAG: 观察者 onNext方法 结果：2
D/TAG: 观察者 onNext方法 结果：1
D/TAG: 观察者 onNext方法 结果：5
D/TAG: 观察者 onNext方法 结果：3
D/TAG: 观察者 onNext方法 结果：2
D/TAG: 观察者 onNext方法 结果：6
D/TAG: 观察者 onNext方法 结果：4
D/TAG: 观察者 onNext方法 结果：7
D/TAG: 观察者 onNext方法 结果：3
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----：false
D/TAG: onDestroy方法 断开订阅
4.mergeDelayError()&mergeArrayDelayError()
<1> 作用
分别对应merge()&mergeArray()。区别在于组合多个被观察者中有观察者出错时的表现。mergeDelayError()&mergeArrayDelayError()当组合的多个被观察者有错误的时。可以继续执行下面的观察者。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import java.util.concurrent.TimeUnit;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava mergeDelayError组合符
*/
public void method() {
Observable.mergeDelayError(
Observable.intervalRange(2, 3, 1, 1, TimeUnit.SECONDS),
Observable.intervalRange(1, 3, 1, 1, TimeUnit.SECONDS),
Observable.create(new ObservableOnSubscribe<Long>() {
@Override
public void subscribe(ObservableEmitter<Long> e) throws Exception {
if (null == e) {
return;
}
if (!e.isDisposed()) {
e.onNext(123L);
e.onError(new Throwable());
}
}
}),
Observable.intervalRange(5, 3, 1, 1, TimeUnit.SECONDS)
).subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接：" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果：" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----：" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}错误模拟：直接onError中发送错误信息。
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接：false
D/TAG: 观察者 onNext方法 结果：123
D/TAG: 观察者 onNext方法 结果：2
D/TAG: 观察者 onNext方法 结果：1
D/TAG: 观察者 onNext方法 结果：5
D/TAG: 观察者 onNext方法 结果：3
D/TAG: 观察者 onNext方法 结果：2
D/TAG: 观察者 onNext方法 结果：6
D/TAG: 观察者 onNext方法 结果：4
D/TAG: 观察者 onNext方法 结果：3
D/TAG: 观察者 onNext方法 结果：7
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----：false
D/TAG: onDestroy方法 断开订阅
5. Zip()
<1> 作用
合并 多个被观察者 发送的事件，生成一个新的事件序列（即组合过后的事件序列），并最终发送。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.BiFunction;
public class MainActivity extends AppCompatActivity {
private Disposable disposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava zip组合符
*/
public void method() {
Observable observable1 = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
if (e == null) {
return;
}
if (!e.isDisposed()) {
e.onNext("observable1 发送 111");
e.onNext("observable1 发送 222");
e.onNext("observable1 发送 333");
}
}
});
Observable observable2 = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
if (e == null) {
return;
}
if (!e.isDisposed()) {
e.onNext("observable2 发送 AAA");
e.onNext("observable2 发送 BBB");
e.onNext("observable2 发送 CCC");
}
}
});
Observable.zip(observable1, observable2, new BiFunction() {
@Override
public Object apply(Object o, Object o2) throws Exception {
String s1 = (String) o;
String s2 = (String) o2;
return s1 + " " + s2;
}
}).subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
disposable = d;
Log.d("TAG", "观察者 onSubscribe方法 是否断开连接：" + disposable.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者 onNext方法 结果：" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != disposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----：" + disposable.isDisposed());
if (!disposable.isDisposed()) {//没有断开
disposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者 onSubscribe方法 是否断开连接：false
D/TAG: 观察者 onNext方法 结果：observable1 发送 111 observable2 发送 AAA
D/TAG: 观察者 onNext方法 结果：observable1 发送 222 observable2 发送 BBB
D/TAG: 观察者 onNext方法 结果：observable1 发送 333 observable2 发送 CCC
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----：false
D/TAG: onDestroy方法 断开订阅
6.combineLatest()&combineLatestDelayError()
<1> 作用
和Zip()类似。Zip()：按个数合并，即1对1合并。CombineLatest()：按时间合并，即在同一个时间点上合并。带Error的和上述一样，处理错误信息时有区别。
<2> 代码
略
<3> 结果
略
7.startWith()&startWithArray()
<1> 作用
在一个被观察者发送事件前，追加发送一些数据。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
public class MainActivity extends AppCompatActivity {
private CompositeDisposable compositeDisposable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
compositeDisposable = new CompositeDisposable();
method();
}
/**
* 创建 RxJava startWith()&startWithArray()组合符
*/
public void method() {
Observable.just(1, 2, 3)
.startWith(4)//追加一个数据 类型与发送数据有关
.startWithArray(5, 6, 7)//追加多条数据 类型与发送数据有关
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
compositeDisposable.add(d);
Log.d("TAG", "观察者1 onSubscribe方法 是否断开连接：" + d.isDisposed());
}
@Override
public void onNext(Integer value) {
Log.d("TAG", "观察者1 onNext方法 Integer类型结果：" + value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> e) throws Exception {
if (null == e) {
return;
}
if (!e.isDisposed()) {
e.onNext("字符串类型111111");
e.onNext("字符串类型222222");
e.onNext(6532);
e.onComplete();
}
}
})
.startWith("追加一个数据：一个111")//追加一个数据 类型与发送数据有关
.startWithArray("追加多个数据：多个222", "追加多个数据：多个333")//追加多条数据 类型与发送数据有关
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
if (null == d) {
return;
}
compositeDisposable.add(d);
Log.d("TAG", "观察者2 onSubscribe方法 是否断开连接：" + d.isDisposed());
}
@Override
public void onNext(Object value) {
Log.d("TAG", "观察者2 onNext方法 Object类型结果：" + value.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != compositeDisposable) {
Log.d("TAG", "onDestroy方法 执行时是否断开----：" + compositeDisposable.isDisposed());
if (!compositeDisposable.isDisposed()) {//没有断开
compositeDisposable.dispose();//断开
Log.d("TAG", "onDestroy方法 断开订阅");
}
}
}
}
<3> 结果
D/TAG: 观察者1 onSubscribe方法 是否断开连接：false
D/TAG: 观察者1 onNext方法 Integer类型结果：5
D/TAG: 观察者1 onNext方法 Integer类型结果：6
D/TAG: 观察者1 onNext方法 Integer类型结果：7
D/TAG: 观察者1 onNext方法 Integer类型结果：4
D/TAG: 观察者1 onNext方法 Integer类型结果：1
D/TAG: 观察者1 onNext方法 Integer类型结果：2
D/TAG: 观察者1 onNext方法 Integer类型结果：3
D/TAG: 观察者2 onSubscribe方法 是否断开连接：false
D/TAG: 观察者2 onNext方法 Object类型结果：追加多个数据：多个222
D/TAG: 观察者2 onNext方法 Object类型结果：追加多个数据：多个333
D/TAG: 观察者2 onNext方法 Object类型结果：追加一个数据：一个111
D/TAG: 观察者2 onNext方法 Object类型结果：字符串类型111111
D/TAG: 观察者2 onNext方法 Object类型结果：字符串类型222222
D/TAG: 观察者2 onNext方法 Object类型结果：6532
<4> 关闭页面
D/TAG: onDestroy方法 执行时是否断开----：false
D/TAG: onDestroy方法 断开订阅
8.count()
<1> 作用
统计被观察者发送事件的数量。
<2> 代码
package com.example.rxjava20;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.Observable;
import io.reactivex.functions.Consumer;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
method();
}
/**
* 创建 RxJava count组合符
*/
public void method() {
Observable.just(1, 2, 3, 4, 5)
.count()
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.d("TAG", "被观察者发送的事件数量----：" + aLong);
}
});
}
}
<3> 结果
D/TAG: 被观察者发送的事件数量----：5
1663
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
