Rxjava操作符之组合合并操作符

Rxjava常见的组合合并操作符如下:

1.concat()/ concatArray()

//组合 / 合并操作符concat() concatArray()
        //组合多个被观察者的事件，合并后在一起按照串行顺序进行发送
        //concat()和concatArray()前者最多合并4个而后者则可以合并>4个的Observable对象的事件序列
        //concat(Iterable)通过集合的形式也是可以合并超过4个Observable事件序列的
        Observable.concat(Observable.just(1,2,3),
                Observable.just(4,5,6),
                Observable.just(7,8,9),
                Observable.just(10,11,12)).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: thread " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer + " thread " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: thread " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: thread " + Thread.currentThread().getName());
            }
        });

        Log.d(TAG, "-------------------------------------------------------------");

        Observable.concatArray(Observable.just(1,2,3),
                Observable.just(4,5,6),
                Observable.just(7,8,9),
                Observable.just(10,11,12),
                Observable.just(13,14,15),
                Observable.just(16,17,18)).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: thread " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer + " thread " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: thread " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: thread " + Thread.currentThread().getName());
            }
        });

执行结果:    

          

2.merge() / mergeArray()

//组合 / 合并操作符merge() / mergeArray()
        //组合多个被观察者Observable一起发送数据
        //concat()/concatArray() 组合后是按照事件序列的顺序串行的执行的
        //而merge()/ mergeArray()组合后是按照时间线的顺序并行执行的
        Observable.merge(Observable.intervalRange(2,4,2,1,TimeUnit.SECONDS),
                Observable.intervalRange(3,3,2,1,TimeUnit.SECONDS),
                Observable.intervalRange(4,5,3,2,TimeUnit.SECONDS,AndroidSchedulers.mainThread())).subscribe(new Consumer<Long>() {
            @Override
            public void accept(@NonNull Long integer) throws Exception {
                Log.d(TAG, "accept: " + integer + " thread " + Thread.currentThread().getName());
            }
        });

   打印结果:

3.concatDelayErro() / mergeDelayError()

//这种情况下 当第一个Observerble被观察者发出了error事件后 
        //此时第二个Observable对象的事件将不会被发送会中断事件队列的发送
        Observable.concat(Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onError(new RuntimeException("出现异常 之后的Observable的事件将不会继续发送"));
            }
        }),Observable.just(4,5,6)).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: thread = " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer + " thread = " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: " + e.getMessage() + " thread = " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: thread = " + Thread.currentThread().getName());
            }
        });

打印结果:

     

//使用concatArrayDelayError避免由于error事件中断事件流的发送
        Observable.concatArrayDelayError(Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onError(new RuntimeException("出现异常 但是会在事件序列中所有的事件都发送完成以后再进行处理"));
            }
        }),Observable.just(4,5,6)).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: thread = " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer + " thread = " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: " + e.getMessage() + " thread = " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: thread = " + Thread.currentThread().getName());
            }
        });

打印结果：

   

4.zip()

    

//合并操作符之zip()
        //zip()操作符可以将多个Observable事件序列按照对应的顺序组合合并成为一个新的事件序列发射出去
        //zip()是按照一一对应的关系来来进行事件序列组合的生成的新的事件序列的事件个数
        //为所有合并事件序列中最少的事件序列的个数
        Observable.zip(Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        }),Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("A");
                e.onNext("B");
                e.onNext("C");
                e.onNext("D");
                e.onComplete();
            }
        }), new BiFunction<Integer, String, String>() {
                    @Override
                    public String apply(@NonNull Integer integer, @NonNull String s) throws Exception {
                        Log.d(TAG, "apply: thread = " + Thread.currentThread().getName());
                        return new StringBuilder().append(integer).append(s.toLowerCase()).toString();
                    }
                })
                .subscribeOn(Schedulers.io()) //Observable调度运行在io线程
                .observeOn(AndroidSchedulers.mainThread()) //观察者Observer回调运行在安卓主线程
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: thread = " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, "onNext: " + s + " thread = " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "onError: " + e.getMessage() + " thread = " + Thread.currentThread().getName());
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete: thread = " + Thread.currentThread().getName());
                    }
                });

打印结果:

      

5.combineLatest()

//组合合并操作符combineLatest()
        //和zip()操作符不同的是比如zip()是将Observable1的事件1和Observable2的事件1进行一一对应的组合
        //合并产生一个新的事件交由总的Observable发射出去
        //而combineLatest()的原理则是它会存储每个Observable最近的值
        //而当其中的任意一个Observable发射新值得时候总的Observable 就会把各个Observable的最近的值给合并起来
        //进行发射出去(combine all the Observable's lastest value together and send to Function)
        Observable.combineLatest(Observable.intervalRange(1L,4L,1L,1L,TimeUnit.SECONDS),
                Observable.just("A", "B", "C"),
                new BiFunction<Long, String, String>() {
                    @Override
                    public String apply(@NonNull Long integer, @NonNull String s) throws Exception {
                       return new StringBuilder().append(integer).append(s).toString();
                    }
                })
                .subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                Log.d(TAG, "accept: " + s);
            }
        });

打印结果:

    

CombineLatest的理解示意图:

 

Observable.combineLatest(Observable.intervalRange(1l, 4l, 0l, 1l, TimeUnit.SECONDS),
                Observable.just("A", "B", "C", "D"),
                new BiFunction<Long, String, String>() {
                    @Override
                    public String apply(@NonNull Long aLong, @NonNull String s) throws Exception {
                        return new StringBuilder().append(aLong).append(s.toLowerCase()).toString();
                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                Log.d(TAG, "accept: " + s);
            }
        });

打印结果:

      

理解示例图:

      

6.reduce()合并操作符

//组合合并操作符之reduce()
        //reduce()操作符的作用是将被观察者Observable发送的事件聚合成为一个事件并且最终发送出去
        //reduce()聚合操作符聚合数据的逻辑可以自己在apply()中自己进行定义 但是其聚合数据的
        //本质是依次将相邻的两个数据进行聚合然后在又与写一个数据进行聚合 如此依次进行数据的聚合
        Observable.just("A","B","C","D")
                .reduce(new BiFunction<String, String, String>() {
                    @Override
                    public String apply(@NonNull String s, @NonNull String s2) throws Exception {
                        //在该方法中定义自己数据聚合的逻辑
                        return new StringBuilder().append(s.toLowerCase()).append(s2.toLowerCase()).toString();
                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                Log.d(TAG, "accept: " + s);
            }
        });

        Log.d(TAG, "--------------------------------------------------------------------");

        Observable.just(1,2,3,4)
                .reduce(new BiFunction<Integer, Integer, Integer>() {
                    @Override
                    public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
                        Integer result = integer * integer2;
                        Log.d(TAG, integer + " 乘以 " + integer2 + " = " + result);
                        return  result;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer integer) throws Exception {
                Log.d(TAG, "accept: 最终结果为" + integer);
            }
        });

打印结果:

7. collect()操作符

//组合合并操作符值collect()
        //collect()的作用是可以将被观察者发送的一系列数据事件
        //使用我们自己的逻辑给收集到一个指定的数据容器里面
        Observable.just(1,2,3,4)
                .collect(new Callable<List<Integer>>() {
                    @Override
                    public List<Integer> call() throws Exception {
                        //在Callable的call方法中创建收集数据的容器
                        Log.d(TAG, "call: 创建了一个收集数据的集合容器");
                        return new ArrayList();
                    }
                }, new BiConsumer<List<Integer>, Integer>() {
                    @Override
                    public void accept(@NonNull List<Integer> integers, @NonNull Integer integer) throws Exception {
                        //在BiConsumer中的accept方法中使用创建好的数据容器进行数据的收集
                        Log.d(TAG, "accept: 容器收集了数据 : " + integer);
                        integers.add(integer);
                        Log.d(TAG, "accept: 容器中此时所有收集的数据为: " + integers.toString());
                    }
                }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<List<Integer>>() {
                    @Override
                    public void accept(@NonNull List<Integer> integers) throws Exception {
                        Log.d(TAG, "accept: 最终收集的数据为: " + integers);
                    }
                });

打印结果:

 

8.startWith() / startWithArray() 

//追加操作符startWith()/startWithArray()
        //startWith()/startWithArray()的作用是在一个被观察者Observable
        //发送事件前追加发送一些新的数据或者新的Observable
        Observable.just(1,2,3)
                .startWith(0)  //追加单个的数据
                .startWith(Observable.just(-3,-2,-1)) //追加一个新的Observable被观察者
                .startWithArray(10,9,8) //追加多个新的数据
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(@NonNull Integer integer) throws Exception {
                        Log.d(TAG, "accept: " + integer);
                    }
                });

打印结果:

         

9. count()

 //统计事件个数操作符之count()
        //count()操作符用于统计我们被观察者Observable发送的事件的个数
        Observable.just(1,2,3,4,5)
                .count()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(@NonNull Long aLong) throws Exception {
                        Log.d(TAG, "发送的事件个数为: " + aLong);
                    }
                });

打印结果: