这一节 接着看RxJava的操作符，官网地址，有事没事看点英文也挺好。
map: map转换符，这个map操作符很简单，进行一些数据的转换：
Observable.just(1, 2, 3)
.map(new Function<Integer, Integer>() {
@Override
public Integer apply(Integer integer) throws Exception {
return integer * 2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer s) throws Exception {
Log.i(TAG, "accept: s = " + s);
}
});
结果：
accept: s = 2
accept: s = 4
accept: s = 6
map操作符其实很常用，在我们请求网络数据之后，或者查询数据库之后，可以把相应的数据转换成ben对象等对数据进行处理
flatMap：flatMam是一个很用的转换器，他可以将一个observable转换为多个observable,并在这多个observable做你想做的操作：
Observable.fromArray(1, 2)
.flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
final int t = integer;
return new Observable<String>() {
@Override
protected void subscribeActual(Observer<? super String> observer) {
observer.onNext(t * 2 + "");
observer.onNext(t * 3 + "");
}
};
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: s = " + s);
}
});
//结果如下,实际上转换成了两个发射器，所以必然打印四个数字：
accept: s = 2
accept: s = 3
accept: s = 4
accept: s = 6
buffer： buffer这个操作符是一个集合操作符，可以把数据缓存成集合：
Observable.fromArray(1, 2, 3)
.buffer( 3, 1)
.subscribe(new Consumer<List<Integer>>() {
@Override
public void accept(List<Integer> integers) throws Exception {
Log.i(TAG, "accept: " + integers.toString());
}
});
结果如下：
accept: [1, 2, 3]
accept: [2, 3]
accept: [3]
如果buffer(3, 1)后面的1去掉的话那么久一次全部打印出出来，就结束了。
scan： scan这个操作符的作用会根据前两个数据的结果发射给观察者，并把这个结果进行下一次的运算，说起来有点绕，看下面的例子：
Observable.fromArray(1, 2, 3)
.scan(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
return integer + integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: integer = " + integer);
}
});
结果：
accept: integer = 1
accept: integer = 3
accept: integer = 6
卡可能已看出，第一次输出1，第二次输出1 + 2 = 3，第三次是3 + 3 = 6
groupBy：groupBy这个操作符根据字面意思来说 就是分组的意思，将被观察者按一定的条件进行分组，这个条件叫做key：
Observable.fromArray(1, 2, 3, 4, 5, 6 ,7)
.groupBy(new Function<Integer, Integer>() {
@Override
public Integer apply(Integer integer) throws Exception {
return integer % 2;
}
}).subscribe(new Consumer<GroupedObservable<Integer, Integer>>() {
@Override
public void accept(GroupedObservable<Integer, Integer> integerIntegerGroupedObservable) throws Exception {
if(integerIntegerGroupedObservable.getKey() == 0){
integerIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: integer = " + integer);
}
});
}else{
Log.i(TAG, "accept: 奇数");
}
}
});
结果：
奇数
integer = 2
integer = 4
integer = 6
上面的代码中按奇数和偶数进行分组，key想相同的放到同一个observable中，分组之后按组发射给下游的观察者
