rxjava2变换运算符
GroupBy
将一个Observable分拆为一些Observables集合,它们中的每一个发射原始Observable的一个子序列,GroupBy操作符将原始Observable分拆为一些Observables集合,它们中的每一个发射原始Observable数据序列的一个子序列。哪个数据项由哪一个Observable发射是由一个函数判定的,这个函数给每一项指定一个Key,Key相同的数据会被同一个Observable发射。
groupBy顾名思义是以xxx分组,groupBy的Function中,自定义分组逻辑将每个信息分配到对应的组,并将组的key标志返回。GroupedObservable就可以根据key来筛选获得对应组的元素。
举个例子:
private void doSomeWork() {
Observable.range(0, 10)
.groupBy(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return integer % 2 == 0 ? "分组key1" : "分组key2";
}
}).subscribe(new Consumer<GroupedObservable<String, Integer>>() {
@Override
public void accept(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) throws Exception {
Log.d(TAG, " accept : key : " + stringIntegerGroupedObservable.getKey());
if (stringIntegerGroupedObservable.getKey().equalsIgnoreCase("分组key1"))
stringIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, " accept : key : " + stringIntegerGroupedObservable.getKey() + ",value : " + integer);
}
});
}
});
}
将奇数、偶数分组,偶数分组设置个key,key可以自定义,这里就叫分组key1;奇数分组key叫分组key2。
打印结果
accept : key : 分组key1
accept : key : 分组key1,value : 0
accept : key : 分组key2
accept : key : 分组key1,value : 2
accept : key : 分组key1,value : 4
accept : key : 分组key1,value : 6
accept : key : 分组key1,value : 8
Scan
按顺序发出每个连续的值,将该函数的结果作为其自己的第一个发射。然后 将函数的结果与源Observable发出的第二个项一起反馈到函数中,生成其第二个发射, 依此类推。
Scan扫描,它会顺序的发射元素,通过scan函数里面自定义的操作后,将自定义操作后的值作为第一个元素传到下次scan函数中。在某些情况下,这种运算符有时被称为“累加器”。所以我们举个累加的例子:
private void doSomeWork() {
Observable.range(0, 5)
.scan(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
Log.d(TAG, " accept : integer : " + integer + ",integer2 : " + integer2);
return integer + integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, " accept : integer : " + integer);
}
});
}
打印结果
accept : integer : 0
accept : integer : 0,integer2 : 1
accept : integer : 1
accept : integer : 1,integer2 : 2
accept : integer : 3
accept : integer : 3,integer2 : 3
accept : integer : 6
accept : integer : 6,integer2 : 4
accept : integer : 10
通过打印的结果我们可以看到,scan发射元素是顺序执行的,并且会将函数的执行结果作为下一次函数的第一个参数。
Window
定期将Observable中的项目细分为Observable窗口并发出这些窗口,而不是一次发出一个项目。
Window类似于Buffer,但它不是从源Observable发出项目包,而是发出Observable,每个Observable都从源Observable发出一个项子集,然后用onCompleted通知终止。
举个例子,每三秒将缓冲的数据发射出来:
private void doSomeWork() {
Observable.interval(1, TimeUnit.SECONDS).take(10)
.window(3, TimeUnit.SECONDS)
.subscribe(new Consumer<Observable<Long>>() {
@Override
public void accept(Observable<Long> longObservable) throws Exception {
Log.d(TAG, "Sub Divide begin....");
longObservable.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.d(TAG, " accept : aLong : " + aLong);
}
});
}
});
}
Sub Divide begin....
accept : aLong : 0
accept : aLong : 1
accept : aLong : 2
Sub Divide begin....
accept : aLong : 3
accept : aLong : 4
Sub Divide begin....
accept : aLong : 5
accept : aLong : 6
accept : aLong : 7
Sub Divide begin....
accept : aLong : 8
accept : aLong : 9
参考资料,参考但不局限以下链接
http://reactivex.io/documentation/operators.html#transforming