组合Observable
当我们需要处理多个Observable的时候,我们可以通过Rxjava的组合函数来创建我们自己想要的Observable。
Merge
RxJava的 merge()
方法将两个甚至更多的Observables合并到新的发射数据项里。
public static void main(String... args) {
Observable<Integer> observable1 = Observable.just(1, 2, 3);
Observable<Integer> observable2 = Observable.just(11, 22, 33);
Observable.merge(observable1, observable2)
.subscribe(new Observer<Integer>() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println("onError");
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
这里我们合并了两个Observable生成了一个新的Observable发射。打印结果:</br>
i = 1</br>
i = 2</br>
i = 3</br>
i = 11</br>
i = 22</br>
i = 33</br>
onCompleted</br>
Concat
Rxjava的concat()
用于将多个Observables合并进行发射,与merge()
的合并不同的是,concat()
严格按照顺序发射数据,前一个Observable没有发射完就不会发射后面的Observable。
ZIP
当然,我们有时候不仅仅想只是合并Observable,还希望能够对数据进行处理再发射出去。RxJava有一个特殊的方法可以完成: zip()
合并两个或者多个Observables发射出的数据项,根据指定的函数 Func*
变换它们,并发射一个新值。
public static void main(String... args) {
Observable<Integer> observable1 = Observable.just(1, 2, 3);
Observable<Integer> observable2 = Observable.just(11, 22, 33);
Observable.zip(observable1, observable2, new Func2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer integer, Integer integer2) {
return integer * integer2;
}
})
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("i = " + integer);
}
});
}
这里我们传入了一个Fun2()
,在call()
方法中对数据进行了相乘的处理,打印结果:</br>
i = 11</br>
i = 44</br>
i = 99</br>
Join
RxJava的 join()
函数基于时间将两个Observables发射的数据结合在一起。先说说它的参数:join(Observable, Func1, Func1, Func2)
Observable
:与源Observable结合的ObservableFunc1
:接收从源Observable发射的数据,并返回一个Observable,该Observable将会指定一个时间周期作为源Observable发射出来数据的有效期。Func1
:接收第二个Observable发射的数据,也返回一个Observable,同样指定一个时间周期作为第二个Observable发射出来数据的有效期。-
Func2
:接收从源Observable和第二个Observable发射的数据,并将接收到的数据进行组合后返回。public static void main(String... args) {
final String[] s = new String[]{"A", "B", "C", "D", "E", "F"};
Observable<String> observable1 = Observable.interval(1500, TimeUnit.MILLISECONDS)
.map(new Func1<Long, String>() {
@Override
public String call(Long aLong) {
return s[aLong.intValue()];
}
}).take(5);
Observable<Long> observable2 = Observable.interval(1500, TimeUnit.MILLISECONDS); observable1.join(observable2, new Func1<String, Observable<Long>>() {
@Override
public Observable<Long> call(String s) {
return Observable.timer(1, TimeUnit.SECONDS);
}
}, new Func1<Long, Observable<Long>>() {
@Override
public Observable<Long> call(Long aLong) {
return Observable.timer(1, TimeUnit.SECONDS);
}
}, new Func2<String, Long, String>() {
@Override
public String call(String s, Long aLong) {
return s + aLong;
}
})
.subscribe(new Observer<String>() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
} @Override
public void onError(Throwable e) {
System.out.println("onError");
} @Override
public void onNext(String s) {
System.out.println("result = " + s);
}
});
}
首先我们创建了一个Observable1
,它将每过1500ms依次发射字符串数组中的一个字母,之后又创建了Observable2
,同样每过1500ms依次发射1,2,3...,之后通过join()
将两个数据组合在一起,打印结果:</br>
result = A0</br>
result = B1</br>
result = C2</br>
result = D3</br>
result = E4</br>
onCompleted</br>
这里有一个小疑惑,在Android Studio进行RunMain()
方法并没有打印出结果就结束了,而我通过debug则打印出了完整的结果,如果有厉害的大神还望多多指教。
combineLatest
Rxjava的combineLatest()
函数有点像zip()
函数的特殊形式,只不过zip()
作用于最近还没有发射的两个Observables,而combineLatest()
作用于最近发射的Observables。通过一张图更清晰:
这里假如这两个可观测序列是同步发射的,一开始A序列发射的1,接着时间到了B发射了A,所以通过combineLatest((x , y) => "" +x+y)
变成了1A,然后又到了A发射2的时间点,就组合成了2A,马上B发射了字母B,又组合成了2B,可以看出combineLatest()
就是组合Observables发射的最新的数据,而且一旦Observables发射了数据,它也立马接收组合发射新的组合数据。
public static void main(String... args) {
final String[] s = new String[]{"A", "B", "C", "D", "E", "F"};
Observable<String> observable1 = Observable.interval(1500, TimeUnit.MILLISECONDS)
.map(new Func1<Long, String>() {
@Override
public String call(Long aLong) {
return s[aLong.intValue()];
}
}).take(4);
Observable<Long> observable2 = Observable.interval(1000, TimeUnit.MILLISECONDS).take(5);
Observable.combineLatest(observable1, observable2, new Func2<String, Long, String>() {
@Override
public String call(String s, Long aLong) {
return s + aLong;
}
})
.subscribe(new Observer<String>() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println("onError");
}
@Override
public void onNext(String s) {
System.out.println("s = " + s);
}
});
}
这还是join()
的代码,只是将join()
换成了combineLatest()
,打印结果:</br>
s = A0</br>
s = A1</br>
s = B1</br>
s = B2</br>
s = B3</br>
s = C3</br>
s = C4</br>
s = D4</br>
s = F4</br>
onCompleted</br>
StartWith
在Observable开始发射其数据的时候,Rxjava的startWith()
通过传递一个参数来先发射一个数据序列。
public static void main(String... args) {
Observable.just(1, 2, 3)
.startWith(7, 8, 9)
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("i = " + integer);
}
});
}
在代码中,我们设置了在发射1,2,3之前先发射7,8,9;打印结果:</br>
i = 7</br>
i = 8</br>
i = 9</br>
i = 1</br>
i = 2</br>
i = 3</br>
作者:cgzysan
链接:https://www.jianshu.com/p/14f143c7a3a0
來源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。