Buffer
定期收集 Observable 的数据放进一个数据包裹，然后发射这些数据包裹，而不是一次发射一个值。
如果原来的 Observable 发射了一个 onError 通知，buffer 会立即传递这个通知，而不是首先发射缓存的数据，即使在这之前缓存中包含了原始 Observable 发射的数据。
buffer(count)
每次取count项发射，最后一次发射可能不足count。
Observable.range(1, 10)
.buffer(3)
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
System.out.println(System.currentTimeMillis() + " - onSubscribe");
}
@Override
public void onNext(@NonNull List<Integer> integers) {
System.out.print(System.currentTimeMillis() + " - onNext :");
integers.forEach(integer -> System.out.print(integer + ", "));
System.out.print("\n");
}
@Override
public void onError(@NonNull Throwable e) {
System.out.println(System.currentTimeMillis() + " - onError");
}
@Override
public void onComplete() {
System.out.println(System.currentTimeMillis() + " - onComplete");
}
});
结果：
1601255341905 - onSubscribe
1601255341928 - onNext :1, 2, 3,
1601255341930 - onNext :4, 5, 6,
1601255341930 - onNext :7, 8, 9,
1601255341931 - onNext :10,
1601255341931 - onComplete
buffer(timeSpan, timeUnit)
每个指定时间间隔发射一次，默认情况下会使用computation调度器，可指定调度器。
Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
try {
for (int i = 1; i <= 10; i++) {
Thread.sleep(1000);
emitter.onNext(i);
}
emitter.onComplete();
} catch (Exception ex) {
emitter.onError(ex);
}
})
.buffer(3, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
System.out.println(System.currentTimeMillis() + " - onSubscribe");
}
@Override
public void onNext(@NonNull List<Integer> integers) {
System.out.print(System.currentTimeMillis() + " - onNext :");
integers.forEach(integer -> System.out.print(integer + ", "));
System.out.print("\n");
}
@Override
public void onError(@NonNull Throwable e) {
System.out.println(System.currentTimeMillis() + " - onError");
}
@Override
public void onComplete() {
System.out.println(System.currentTimeMillis() + " - onComplete");
}
});
结果：
1601255476314 - onSubscribe
1601255479326 - onNext :1, 2,
1601255482326 - onNext :3, 4, 5,
1601255485326 - onNext :6, 7, 8,
1601255486335 - onNext :9, 10,
1601255486337 - onComplete
Window
和 Buffer 类似，但不是发射来自原始 Observable 的数据包，它发射的是 Observables，这些 Observables 中的每一个都发射原始 Observable 数据的一个自己，最后发射一个 onComplated 通知。
windows 操作符在发射之前把收集到的数据放进单独的 Observable，而不是放进一个数据结构。
Observable.range(1, 10)
.window(3)
.subscribe(new Consumer<Observable<Integer>>() {
@Override
public void accept(Observable<Integer> integerObservable) throws Throwable {
int delay = new Random().nextInt(5);
System.out.println(System.currentTimeMillis() + " - acceptObservable: " + delay);
integerObservable.map(integer -> integer > 9 ? "0" + integer : "00" + integer)
.delay(delay, TimeUnit.SECONDS)
.subscribe(s -> System.out.println(System.currentTimeMillis() + " - accept :" + s));
}
});
结果：
1601263262565 - acceptObservable: 3
1601263262584 - acceptObservable: 3
1601263262587 - acceptObservable: 1
1601263262590 - acceptObservable: 4
1601263263590 - accept :007
1601263263593 - accept :008
1601263263595 - accept :009
1601263265583 - accept :001
1601263265585 - accept :002
1601263265586 - accept :004
1601263265587 - accept :003
1601263265590 - accept :005
1601263265592 - accept :006
1601263266594 - accept :010
Map
对原始Observable发射的每一项数据应用一个你选择的函数，然后返回一个发射这些结果的Observable。
map 操作符默认不在任何特定的调度器上执行。
Observable.just(1, 2, 3, 4, 5)
.map(integer -> integer + "---")
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
System.out.println(System.currentTimeMillis() + " - onSubscribe");
}
@Override
public void onNext(@NonNull String s) {
System.out.println(System.currentTimeMillis() + " - onNext :" + s);
}
@Override
public void onError(@NonNull Throwable e) {
System.out.println(System.currentTimeMillis() + " - onError");
}
@Override
public void onComplete() {
System.out.println(System.currentTimeMillis() + " - onComplete");
}
});
结果：
1601256115471 - onSubscribe
1601256115482 - onNext :1---
1601256115483 - onNext :2---
1601256115483 - onNext :3---
1601256115484 - onNext :4---
1601256115484 - onNext :5---
1601256115484 - onComplete
FlatMap
将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable。
map 变换后可以返回任意值，flatMap 只能返回 ObservableSource。
map 只能进行一对一的变换，flatMap 可以进行一对一，一对多，多对多的变换。flatMap(Func1)
Observable.just(1, 2, 3, 4, 5)
.flatMap((Function<Integer, ObservableSource<List<Integer>>>) integer -> {
if (integer == 3) {
return Observable.empty();
}
int delay = new Random().nextInt(3);
List<Integer> result = new ArrayList<>();
for (int i=0; i<integer; i++) {
result.add(i);
}
return Observable.fromArray(result).delay(delay, TimeUnit.SECONDS);
})
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
System.out.println(System.currentTimeMillis() + " - onSubscribe");
}
@Override
public void onNext(@NonNull List<Integer> s) {
System.out.println(System.currentTimeMillis() + " - onNext :" + s);
}
@Override
public void onError(@NonNull Throwable e) {
System.out.println(System.currentTimeMillis() + " - onError");
}
@Override
public void onComplete() {
System.out.println(System.currentTimeMillis() + " - onComplete");
}
});
结果：
1601260524772 - onSubscribe
1601260524795 - onNext :[0]
1601260524796 - onNext :[0, 1, 2, 3]
1601260525785 - onNext :[0, 1]
1601260525791 - onNext :[0, 1, 2, 3, 4]
1601260525795 - onComplete
concatMap(Func1)
按次序连接而不是合并那些生成的 Observables，然后产生自己的数据序列。
可解决 flatMap 在转化数据过程中会出现的任务交叉问题。
Observable.just(1, 2, 3, 4, 5)
.concatMap((Function<Integer, ObservableSource<List<Integer>>>) integer -> {
if (integer == 3) {
return Observable.empty();
}
int delay = new Random().nextInt(3);
List<Integer> result = new ArrayList<>();
for (int i=0; i<integer; i++) {
result.add(i);
}
return Observable.fromArray(result).delay(delay, TimeUnit.SECONDS);
}).subscribe(integers -> System.out.println(System.currentTimeMillis() + " - accept :" + integers));
结果：
1601260598528 - accept :[0]
1601260599534 - accept :[0, 1]
1601260600542 - accept :[0, 1, 2, 3]
1601260600549 - accept :[0, 1, 2, 3, 4]
switchMap(Func1)
当原始 Observable 发射一个新的数据（Observable）时，它将取消订阅并停止监视之前的 Observable，只监视当前这一个。
Observable.just(1, 2, 3, 4, 5)
.switchMap((Function<Integer, ObservableSource<List<Integer>>>) integer -> {
if (integer == 3) {
return Observable.empty();
}
int delay = new Random().nextInt(3);
List<Integer> result = new ArrayList<>();
for (int i=0; i<integer; i++) {
result.add(i);
}
return Observable.fromArray(result).delay(delay, TimeUnit.SECONDS);
}).subscribe(integers -> System.out.println(System.currentTimeMillis() + " - accept :" + integers));
结果：
1601260700298 - accept :[0, 1, 2, 3, 4]
flatMapIterable(Func1)
成对的打包数据，然后生成 Iterable 而不是原始数据和生成的 Observables，但是处理方式是相同的。
Observable.just(1, 2, 3, 4, 5)
.flatMapIterable((Function<Integer, Iterable<String>>) integer -> Arrays.asList("a" + integer, "b" + integer, "c" + integer))
.subscribe(s -> System.out.println(System.currentTimeMillis() + " - accept :" + s));
结果：
1601260736042 - accept :a1
1601260736042 - accept :b1
1601260736042 - accept :c1
1601260736043 - accept :a2
1601260736043 - accept :b2
1601260736043 - accept :c2
1601260736043 - accept :a3
1601260736043 - accept :b3
1601260736043 - accept :c3
1601260736043 - accept :a4
1601260736044 - accept :b4
1601260736044 - accept :c4
1601260736044 - accept :a5
1601260736044 - accept :b5
1601260736044 - accept :c5
GroupBy
将原始 Observable 拆分为一些 Observables 集合，它们中的每一个发射原始 Observable 数据序列的一个子序列。哪个数据项又哪一个 Observable 发射是由一个函数判定的，这个函数给每一项指定一个 key，key 相同的数据会被同一个 Observable发射。
Observable.range(1, 10)
.groupBy(integer -> integer % 2)
.subscribeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(integerIntegerGroupedObservable -> {
Integer key = integerIntegerGroupedObservable.getKey();
System.out.println(System.currentTimeMillis() + " - acceptGroupedObservable :" + key);
integerIntegerGroupedObservable.delay((key + 1) * 2, TimeUnit.SECONDS)
.subscribe(integer -> System.out.println(System.currentTimeMillis() + " - accept :" + integer));
});
结果：
1601263793952 - acceptGroupedObservable :1
1601263793956 - acceptGroupedObservable :0
1601263793959 - acceptGroupedObservable :1
1601263793961 - acceptGroupedObservable :0
1601263793963 - acceptGroupedObservable :1
1601263793964 - acceptGroupedObservable :0
1601263793966 - acceptGroupedObservable :1
1601263793967 - acceptGroupedObservable :0
1601263793968 - acceptGroupedObservable :1
1601263793969 - acceptGroupedObservable :0
1601263795959 - accept :2
1601263795963 - accept :4
1601263795966 - accept :6
1601263795969 - accept :8
1601263795971 - accept :10
1601263797957 - accept :1
1601263797961 - accept :3
1601263797965 - accept :5
1601263797968 - accept :7
1601263797970 - accept :9
Scan
对原始Observable发射的第一项数据应用一个函数，然后将那个函数的结果作为自己的第一项数据发射。它将函数的结果同第二项数据一起填充给这个函数来产生它自己的第二项数据。它持续进行这个过程来产生剩余的数据序列。
Observable.range(1, 10)
.scan((integer, integer2) -> integer + integer2)
.subscribe(integer -> System.out.println(System.currentTimeMillis() + " - accept :" + integer));
结果：
1601261177367 - accept :1
1601261177368 - accept :3
1601261177368 - accept :6
1601261177368 - accept :10
1601261177368 - accept :15
1601261177368 - accept :21
1601261177368 - accept :28
1601261177368 - accept :36
1601261177369 - accept :45
1601261177369 - accept :55
参考资料
RxJava中文文档
原文链接：https://blog.youkuaiyun.com/doris_d/article/details/108841837
扫一扫
391
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
