RxJava基础学习3-合并操作符

最新推荐文章于 2022-11-20 12:27:39 发布

又双㕛叕、

最新推荐文章于 2022-11-20 12:27:39 发布

阅读量857

点赞数 1

分类专栏： Android 文章标签： rxjava 学习

本文链接：https://blog.youkuaiyun.com/u010090644/article/details/124706048

版权

Android 专栏收录该内容

54 篇文章

订阅专栏

本文介绍了Observable的zip、merge、concat等操作符，展示了如何合并数据源，转换内容并控制发射顺序。重点讲解了zip的短数据决定长度，merge的无序合并，concat的有序发射，以及error处理的concatDelayError和mergeDelayError。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.zip 操作符

* 把多个Observable合并后，并且把这些Observable的数据进行转换再发射出去。转换之后的数据数目由最短数据长度的那个Observable决定。发射完最终会自动调用观察者的onComplete方法()
*
* 如以下代码：数据长度为6的observable1和数据长度为4的observable2进行合并转换后，观察者只接收到4个数据
*/

Observable observable1 = Observable.just(44, 55, 66, 77, 88, 99);
        Observable observable2 = Observable.just("剑侠客", "逍遥生", "舞天姬", "小明", "小强");

        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String s) throws Exception {
                return integer + s;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String o) {
                Log.d(TAG + "zip", o);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                Log.d(TAG + "zip", "onComplete");
            }
        });

2022-05-11 11:23:54.905 22610-22610/com.app.empty D/MainActivityzip: 44剑侠客
2022-05-11 11:23:54.905 22610-22610/com.app.empty D/MainActivityzip: 55逍遥生
2022-05-11 11:23:54.905 22610-22610/com.app.empty D/MainActivityzip: 66舞天姬
2022-05-11 11:23:54.906 22610-22610/com.app.empty D/MainActivityzip: 77小明
2022-05-11 11:23:54.906 22610-22610/com.app.empty D/MainActivityzip: 88小强
2022-05-11 11:23:54.906 22610-22610/com.app.empty D/MainActivityzip: onComplete

2、merge()，concat ()操作符

* merge操作符是把多个Observable合并成一个进行发射。merge可能会让合并到Observable的数据顺序发生错乱(组合被观察者数量<=4个)(并行无序)
* mergeArray操作符和merge作用一样，但不同的是组合被观察者数量>4个)(并行无序)
* concat操作符也是把多个Observable合并成一个进行发射。但concat则保证合并的每个Observable的事件按顺序发射出去。(组合被观察者数量<=4个)(串行有序)
* concatArray操作符和concat作用一样，但不同的是组合被观察者数量>4个)(串行有序)

Observable observable1 = Observable.just(44, 55, 66, 77, 88, 99);
        Observable observable2 = Observable.just("剑侠客", "逍遥生", "舞天姬", "小明", "小强");

        Observable.merge(observable1, observable2).delay(1, TimeUnit.SECONDS)
                .subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Object o) {
                        Log.d(TAG + "merge", o.toString());
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG + "merge", "onComplete");
                    }
                });

2022-05-11 11:28:38.748 23369-23432/com.app.empty D/MainActivitymerge: 44
2022-05-11 11:28:38.748 23369-23432/com.app.empty D/MainActivitymerge: 55
2022-05-11 11:28:38.748 23369-23432/com.app.empty D/MainActivitymerge: 66
2022-05-11 11:28:38.748 23369-23432/com.app.empty D/MainActivitymerge: 77
2022-05-11 11:28:38.749 23369-23432/com.app.empty D/MainActivitymerge: 88
2022-05-11 11:28:38.749 23369-23432/com.app.empty D/MainActivitymerge: 99
2022-05-11 11:28:38.749 23369-23432/com.app.empty D/MainActivitymerge: 剑侠客
2022-05-11 11:28:38.749 23369-23432/com.app.empty D/MainActivitymerge: 逍遥生
2022-05-11 11:28:38.749 23369-23432/com.app.empty D/MainActivitymerge: 舞天姬
2022-05-11 11:28:38.749 23369-23432/com.app.empty D/MainActivitymerge: 小明
2022-05-11 11:28:38.749 23369-23432/com.app.empty D/MainActivitymerge: 小强
2022-05-11 11:28:38.750 23369-23432/com.app.empty D/MainActivitymerge: onComplete

3.concatDelayError()/mergeDelayError() 操作符

* 这两个操作符的作用是：使用concat()和merge()操作符时，若其中一个被观察者发送onError事件，则会马上终止其它被观察者继续发送事件。所以呐，这时使用concatError()/
* mergeDelayError()事件可以使onError事件推迟到其它被观察者发送事件结束后在再触发

Observable.concatArrayDelayError(Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1111);
                        emitter.onNext(2222);
                        emitter.onError(new NullPointerException());
                        emitter.onNext(3333);
                        emitter.onNext(4444);
                    }
                }), Observable.just(5555, 6666))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG + "cDelayError", String.valueOf(integer));
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG + "cDelayError", "onError");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG + "cDelayError", "onComplete");
                    }
                });

2022-05-11 11:40:08.903 24467-24467/com.app.empty D/MainActivitycDelayError: 1111
2022-05-11 11:40:08.903 24467-24467/com.app.empty D/MainActivitycDelayError: 2222
2022-05-11 11:40:08.904 24467-24467/com.app.empty D/MainActivitycDelayError: 5555
2022-05-11 11:40:08.904 24467-24467/com.app.empty D/MainActivitycDelayError: 6666
2022-05-11 11:40:08.904 24467-24467/com.app.empty D/MainActivitycDelayError: onError

4.reduce ()操作符

* 把被观察者需要发送的数据按照指定规则聚合成一个数据发送

* 聚合的规则需要我们编写，内部流程是前两个数据按照我们的规则合并后，再与后面的数据按规则合并，依次类推。这样说有点抽象，看下面的例子。

其实就是11和22合并，合并后变成 33 33 44 55

在33和33合并变成 66 44 55

在66和44合并变成 110 55

Observable
                .just(11, 22, 33, 44, 55)
                .reduce(new BiFunction<Integer, Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer, Integer integer2) throws Exception {
                        Log.d(TAG + "reduce", "本次合并的过程是：  " + integer + "+" + integer2);
                        return integer + integer2;
                    }
                })
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "reduce", "最终计算的结果是 :  " + integer);
                    }
                });

D/MainActivityreduce: 本次合并的过程是：  11+22
D/MainActivityreduce: 本次合并的过程是：  33+33
D/MainActivityreduce: 本次合并的过程是：  66+44
D/MainActivityreduce: 本次合并的过程是：  110+55
D/MainActivityreduce: 最终计算的结果是 :  165

5.startWith()/startWithArray() 操作符

* 在一个被观察者发送时间前，追加发送一些数据一个新的被观察者

Observable.just(7, 8, 9)
                .startWith(6)   //在发送序列去追加单个数据
                .startWithArray(4, 5)  //在发送序列去追加多个数据
                .startWith(Observable.just(1, 2, 3))  //在发送序列去追加单个被观察者
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "startWith", String.valueOf(integer));
                    }
                });

2022-05-11 11:50:52.131 25233-25233/com.app.empty D/MainActivitystartWith: 2
2022-05-11 11:50:52.131 25233-25233/com.app.empty D/MainActivitystartWith: 3
2022-05-11 11:50:52.131 25233-25233/com.app.empty D/MainActivitystartWith: 4
2022-05-11 11:50:52.131 25233-25233/com.app.empty D/MainActivitystartWith: 5
2022-05-11 11:50:52.131 25233-25233/com.app.empty D/MainActivitystartWith: 6
2022-05-11 11:50:52.131 25233-25233/com.app.empty D/MainActivitystartWith: 7
2022-05-11 11:50:52.131 25233-25233/com.app.empty D/MainActivitystartWith: 8
2022-05-11 11:50:52.131 25233-25233/com.app.empty D/MainActivitystartWith: 9

6、其他操作符

* .count() 操作符统计被观察者发送事件数量

Observable.just(1, 2, 3)
                .count()
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(TAG + "count", "发送事件的数量 ： " + aLong);
                    }
                });

* collect() 操作符作用是把 Observable(被观察者)发送的事件收集到一个数据结构中

Observable.just(1, 2, 3, 4, 5)
                .collect(new Callable<ArrayList<Integer>>() {
                    @Override
                    public ArrayList<Integer> call() throws Exception {
                        return new ArrayList<>();
                    }
                }, new BiConsumer<ArrayList<Integer>, Integer>() {
                    @Override
                    public void accept(ArrayList<Integer> integers, Integer integer) throws Exception {
                        integers.add(integer);
                    }
                })
                .subscribe(new Consumer<ArrayList<Integer>>() {
                    @Override
                    public void accept(ArrayList<Integer> integers) throws Exception {
                        Log.d(TAG + "collect", integers.toString());
                    }
                });

基本常用的就是这些了。