标签：
转载请标明出处：
http://blog.csdn.net/xmxkf/article/details/51649975
本文出自:【openXu的博客】
目录：
??变换操作符的作用是对Observable发射的数据按照一定规则做一些变换操作，然后将变换后的数据发射出去，接下来看看RxJava中主要有哪些变换操作符：
??定期收集Observable的数据放进一个数据包裹，然后发射这些数据包裹，而不是一次发射一个值。
在RxJava中有许多Buffer的变体（下面列举两个示例）：
????
????
示例代码：
//一组缓存3个数据
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
.buffer(3)
.subscribe(i -> Log.d(TAG, "1buffer-count:" + i));
//每隔三个数据缓存2个数据
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
.buffer(2, 3)
.subscribe(i -> Log.d(TAG, "1buffer-count&skip:" + i));
Observable.interval(1, TimeUnit.SECONDS).
buffer(3, TimeUnit.SECONDS)
.subscribe(i -> Log.d(TAG, "2buffer-count:" + i));
Observable.interval(1, TimeUnit.SECONDS).
buffer(2, 3, TimeUnit.SECONDS)
.subscribe(i -> Log.d(TAG, "2buffer-count&skip:" + i));输出：
1buffer-count:[1, 2, 3]
1buffer-count:[4, 5, 6]
1buffer-count:[7, 8, 9]
1buffer-count:[10]1buffer-count&skip:[1, 2]
1buffer-count&skip:[4, 5]
1buffer-count&skip:[7, 8]
1buffer-count&skip:[10]2buffer-count&skip:[0]
2buffer-count:[0, 1]
2buffer-count&skip:[3, 4]
2buffer-count:[2, 3, 4]
2buffer-count&skip:[5, 6]
2buffer-count:[5, 6, 7]
2buffer-count&skip:[8, 9]
2buffer-count:[8, 9, 10]
2buffer-count&skip:[11, 12]
2buffer-count:[11, 12, 13]
…
vFlatMap将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable
????
这个操作符有一个接受额外的int参数的一个变体。这个参数设置flatMap从原来的Observable映射Observables的最大同时订阅数。当达到这个限制时，它会等待其中一个终止然后再订阅另一个。
这个变体成对的打包数据，然后生成Iterable而不是原始数据和生成的Observables，但是处理方式是相同的
它类似于最简单版本的flatMap，但是它按次序连接而不是合并那些生成的Observables，然后产生自己的数据序列。
它和flatMap很像，除了一点：当原始Observable发射一个新的数据（Observable）时，它将取消订阅并停止监视产生执之前那个数据的Observable，只监视当前这一个
示例代码：
//将发射的数据都加上flat map的前缀
Observable.just(1, 2, 3, 4, 5)
.flatMap(integer -> Observable.just("flat map:" + integer))
.subscribe(i -> Log.d(TAG, i));
//会输出n个n数字
Observable.just(1, 2, 3, 4)
.flatMapIterable(
integer -> {
ArrayList<Integer> s = new ArrayList<>();
for (int i = 0; i < integer; i++) {
s.add(integer);
}
return s;
}
)
.subscribe(i -> Log.d(TAG, "flatMapIterable:" + i));输出：
flat map:1
flat map:2
flat map:3
flat map:4
flat map:5
flatMapIterable:1
flatMapIterable:2
flatMapIterable:2
flatMapIterable:3
flatMapIterable:3
flatMapIterable:3
flatMapIterable:4
flatMapIterable:4
flatMapIterable:4
flatMapIterable:4
????
groupBy默认不在任何特定的调度器上执行。
示例代码：
private void op_GroupBy(TextView textView){
// groupBy(Func1)：Func1是对数据分组（确定key）
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
.groupBy(new Func1<Integer, String>() {
@Override
public String call(Integer integer) {
//按照奇数和偶数分组
return integer % 2 == 0 ? "偶数" : "奇数";
}
}).subscribe(new Action1<GroupedObservable<String, Integer>>() {
@Override
public void call(GroupedObservable<String, Integer> groupedObservable) {
// groupedObservable.count()
// .subscribe(integer -> Log.v(TAG, "key" + groupedObservable.getKey() + " contains:" + integer + " numbers"));
groupedObservable.subscribe(value->Log.v(TAG, "key" + groupedObservable.getKey() + " value:"+value));
}
});
// groupBy(Func1,Func1)：Func1是对数据分组（确定key），Func2发射每个数据，在这里面可以对原始数据做处理
Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
.groupBy(new Func1<Integer, String>() {
@Override
public String call(Integer integer) {
//按照奇数和偶数分组
return integer % 2 == 0 ? "偶数" : "奇数";
}
}, new Func1<Integer, String>() {
@Override
public String call(Integer integer) {
//在数字前面加上说明，如果不加这个参数，最后发射的数据就是原始整数
return (integer % 2 == 0 ? "偶数" : "奇数")+integer;
}
}).subscribe(new Action1<GroupedObservable<String, String>>() {
@Override
public void call(GroupedObservable<String, String> groupedObservable) {
// groupedObservable.count()
// .subscribe(integer -> Log.v(TAG, "key" + groupedObservable.getKey() + " contains:" + integer + " numbers"));
groupedObservable.subscribe(value->Log.v(TAG, "key" + groupedObservable.getKey() + " value:"+value));
}
});
}输出：
key奇数 value:1
key偶数 value:2
key奇数 value:3
key偶数 value:4
key奇数 value:5
key偶数 value:6
key奇数 value:7
key偶数 value:8
key奇数 value:9
key奇数 value:奇数1
key偶数 value:偶数2
key奇数 value:奇数3
key偶数 value:偶数4
key奇数 value:奇数5
key偶数 value:偶数6
key奇数 value:奇数7
key偶数 value:偶数8
key奇数 value:奇数9
????
示例代码：
String[] names = {"张三", "李四", "王二", "麻子"};
//map
Observable.from(names).map(new Func1<String, String>() {
@Override
public String call(String s) {
//将原始Observable发射的每一项数据前面加上 “姓名：”
return "姓名:"+s;
}
}).subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.v(TAG, s);
}
});
//cast: 多态中可以将父类引用强转为子类对象
//cast的强转只适用于多态，而不适用于String强转为Integer
Animal animal = new Dog(); //多态
Observable.just(animal)
.cast(Dog.class)
.subscribe(new Action1<Dog>() {
@Override
public void call(Dog dog) {
Log.v(TAG, "Cast ->" + dog);
}
});输出：
姓名:张三
姓名:李四
姓名:王二
姓名:麻子Cast ->com.openxu.rxjava.operators.TransformOperators$Dog@52729440
????
????
示例代码：
//会把原始数据的第一项当做新的第一项发射
Observable.just(1, 2, 3, 4, 5)
.scan(new Func2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer sum, Integer item) {
Log.v(TAG, ">应用函数:" + sum+" ,"+item);
return sum + item;
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.v(TAG, "Next:" + integer);
}
});
//scan将发射种子值3作为自己的第一项数据
Observable.just(1, 2, 3, 4, 5)
.scan(2, new Func2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer sum, Integer item) {
Log.d(TAG, ">应用函数:" + sum+" ,"+item);
return sum + item;
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG, "Next:" + integer);
}
});输出：
Next:1
应用函数:1 ,2
Next:3
应用函数:3 ,3
Next:6
应用函数:6 ,4
Next:10
应用函数:10 ,5
Next:15Next:2
应用函数:2 ,1
Next:3
应用函数:3 ,2
Next:5
应用函数:5 ,3
Next:8
应用函数:8 ,4
Next:12
应用函数:12 ,5
Next:17
????
Window和Buffer类似，但不是发射来自原始Observable的数据包，它发射的是Observables，这些Observables中的每一个都发射原始Observable数据的一个子集，最后发射一个onCompleted通知
和Buffer一样，Window有很多变体，每一种都以自己的方式将原始Observable分解为多个作为结果的Observable，每一个都包含一个映射原始数据的window。用Window操作符的术语描述就是，当一个窗口打开(when a window “opens”)意味着一个新的Observable已经发射（产生）了，而且这个Observable开始发射来自原始Observable的数据；当一个窗口关闭(when a window “closes”)意味着发射(产生)的Observable停止发射原始Observable的数据，并且发射终止通知onCompleted给它的观察者们
示例代码：
Observable.just(1, 2, 3, 4, 5, 6, 7)
.window(3) //每次发射出一个包含三个整数的子Observable
.subscribe(new Action1<Observable<Integer>>() {
@Override
public void call(Observable<Integer> integerObservable) {
//每次发射一个子Observable
Log.d(TAG,integerObservable+"");
//订阅子Observable
integerObservable.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG,"window:" + integer);
}
});
}
});
Observable.just(1, 2, 3, 4, 5, 6, 7)
.window(3, 2) //每次发射出一个包含三个整数的子Observable
.subscribe(new Action1<Observable<Integer>>() {
@Override
public void call(Observable<Integer> integerObservable) {
Log.d(TAG,integerObservable+"");
//订阅子Observable
integerObservable.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.d(TAG,"windowSkip:" + integer);
}
});
}
});输出：
rx.internal.operators.UnicastSubject@52715e4c
window:1
window:2
window:3
rx.internal.operators.UnicastSubject@527164fc
window:4
window:5
window:6
rx.internal.operators.UnicastSubject@527167f0
window:7rx.internal.operators.UnicastSubject@52717474
windowSkip:1
windowSkip:2
rx.internal.operators.UnicastSubject@52717980
windowSkip:3
windowSkip:3
windowSkip:4
rx.internal.operators.UnicastSubject@52717cac
windowSkip:5
windowSkip:5
windowSkip:6
rx.internal.operators.UnicastSubject@52717fd8
windowSkip:7
windowSkip:7
??以上就是RxJava实现的变换相关的操作符，对于不能理解的童鞋，建议将源码运行后对照分析，这样有助于理解。
有问题请留言，有帮助请点赞(^__^)
标签：
原文地址：http://blog.csdn.net/xmxkf/article/details/51649975
