前言
优点：
1、链式操作
2、异步优化
实战
先来个简单的使用示例
Observable
.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
e.onNext("1");
e.onNext("2");
e.onComplete();
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete: ");
}
});输出Log
onNext: 1
onNext: 2
onComplete:
项目依赖
dependencies {
// RxJava
compile 'io.reactivex.rxjava2:rxjava:2.0.8'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
compile 'com.trello.rxlifecycle2:rxlifecycle:2.0.1'
compile 'com.trello.rxlifecycle2:rxlifecycle-android:2.0.1'
compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0'
}线程调度器，用于灵活的切换线程，RxJava内置主要提供了以下几个，基本够用了
Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
Schedulers.newThread() 代表一个常规的新线程
AndroidSchedulers.mainThread() 代表Android的主线程
操作符
变换操作
Map
简单的说就是中间转换层，把被观察者发送的数据->进行转换后->再发送给观察者接收。
用实例来证明
Observable
.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
Log.d(TAG, "onNext: 1");
e.onNext(1);
Log.d(TAG, "onNext: 2");
e.onNext(2);
}
})
.map(new Function<Integer, String>() {
@Override
public String apply(@NonNull Integer integer) throws Exception {
Log.d(TAG, "apply: map");
return "format to string " + integer;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
});输出Log
onNext: 1
apply: map
accept: format to string 1
onNext: 2
accept: format to string 2
FlagMap
将一个发送事件的Observable变换生成新的一个或多个发送事件的Observable，再发送。
注意：合并后发送顺序是无序的。
用实践来证明
Observable
.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
Log.d(TAG, "onNext: 1");
e.onNext(1);
Log.d(TAG, "onNext: 2");
e.onNext(2);
}
})
.flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
Log.d(TAG, "apply: flatMap");
List<String> list = new ArrayList<String>();
for (int i = 0; i < 3; i++) {
list.add("format to string " + integer);
}
return Observable.fromIterable(list);
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
});输出Log
onNext: 1
apply: flatMap
accept: format to string 1
format to string 1
accept: format to string 1
onNext: 2
apply: flatMap
accept: format to string 2
accept: format to string 2
accept: format to string 2
ConcatMap
根FlatMap基本一样，唯一区别就是发送顺序是有序的。
Zip
将多个发送事件的Observable，合并生成一个新的发送事件的Observable，再发送。
注意：合并顺序是严格按照发送顺序来的，并且生成的新的发送事件数量，取发送事件数量最少的那个，这个应该可以理解。
用实例来证明
Observable obb1 = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
Log.d(TAG, "onNext: A");
e.onNext("A");
Log.d(TAG, "onNext: B");
e.onNext("B");
Log.d(TAG, "onNext: C");
e.onNext("C");
Log.d(TAG, "onNext: D");
e.onNext("D");
}
}).subscribeOn(Schedulers.io());
Observable obb2 = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
Log.d(TAG, "onNext: 1");
e.onNext(1);
Log.d(TAG, "onNext: 2");
e.onNext(2);
Log.d(TAG, "onNext: 3");
e.onNext(3);
}
}).subscribeOn(Schedulers.io());
Observable
.zip(obb1, obb2, new BiFunction<String, Integer, String>() {
@Override
public String apply(@NonNull String s, @NonNull Integer integer) throws Exception {
Log.d(TAG, "apply: zip");
return s + "+" + integer;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
});输出Log
onNext: A
onNext: B
onNext: C
onNext: D
onNext: 1
apply: zip
accept: A+1
onNext: 2
apply: zip
accept: B+2
onNext: 3
apply: zip
accept: C+3
……
未完待续