rxjava操作符笔记

zip操作符：合并数据源，并生成新的数据源,会等到所有的数据源完成以后再发射新的数据源,并且第一个数据源的数据永远在回调参数的第一个，依次类推

   Observable<String> o1 = Observable.just("啦啦啦啦").delay(1, TimeUnit.SECONDS);
        Observable<String> o2 = Observable.just("数据").delay(6, TimeUnit.SECONDS);
        Observable.zip(o2, o1, new BiFunction<String, String, String>() {
            @Override
            public String apply(String s, String s2) throws Exception {
                return "新的数据:" + s + s2;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i("==", s);
            }
        });

上面这个例子，o2数据源延迟6秒，o1延迟1秒，因为o2在参数的第一个，所以o1会等待o2,并且在apply参数列表中，o2的发射物在参数的第一位

merge：合并数据源，如果某个数据源先完成，则该数据源的数据先发射

  Observable<String> o1 = Observable.just("啦啦啦啦").delay(1, TimeUnit.SECONDS);
        Observable<String> o2 = Observable.just("数据").delay(6, TimeUnit.SECONDS);
        Observable.merge(o2, o1).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i("==", s);
            }
        });

上面这个例子o1的数据会先发射，并不会因为o2在merge参数的前面而延后

mergeArray：组合被观察者的数量，即merge组合被观察者数量≤4个，而mergeArray则可＞4个

concat：该操作符会根据参数列表数据源的顺序来发射对应的数据

Observable<String> o1 = Observable.just("啦啦啦啦").delay(1, TimeUnit.SECONDS);
        Observable<String> o2 = Observable.just("数据").delay(6, TimeUnit.SECONDS);
        Observable.concat(o2, o1).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i("==", s);
            }
        });

由于o2在o1前面，所以o1会等待o2发射完成再发射

concatArray：组合被观察者的数量，即concat组合被观察者数量≤4个，而concatArray则可＞4个,其他用法一样

concatDelayError:如果使用concat操作符，当其中一个观察者发出onError事件，则会马上终止其他被观察者继续发送事件，若希望onError事件推迟到其他被观察者的后面，则可以使用concatDelayError操作符

无使用concatDelayError的情景：

Observable.concat(
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);
                        emitter.onError(new NullPointerException()); // 发送Error事件，因为无使用concatDelayError，所以第2个Observable将不会发送事件
                        emitter.onComplete();
                    }
                }),
                Observable.just(4, 5, 6))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

测试结果：第1个被观察者发送Error事件后，第2个被观察者则不会继续发送事件,只会打印：

接收到了事件1
接收到了事件2
接收到了事件3

使用了concatDelayError的情况：

Observable.concatArrayDelayError(
                Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);
                        emitter.onError(new NullPointerException()); // 发送Error事件，因为使用了concatDelayError，所以第2个Observable将会发送事件，等发送完毕后，再发送错误事件
                        emitter.onComplete();
                    }
                }),
                Observable.just(4, 5, 6))
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

打印结果：

接收到了事件1
接收到了事件2
接收到了事件3
接收到了事件4
接收到了事件5
接收到了事件6
对Error事件作出响应

combineLatestDelayError:作用类似于concatDelayError / mergeDelayError，即错误处理

reduce:把被观察者需要发送0事件聚合成1个事件 & 发送,聚合的逻辑根据需求撰写，但本质都是前2个数据聚合，然后与后1个数据继续进行聚合，依次类推

Observable.just(1,2,3,4)
                .reduce(new BiFunction<Integer, Integer, Integer>() {
                    // 在该复写方法中复写聚合的逻辑
                    @Override
                    public Integer apply(@NonNull Integer s1, @NonNull Integer s2) throws Exception {
                        Log.e(TAG, "本次计算的数据是： "+s1 +" 乘 "+ s2);
                        return s1 * s2;
                        // 本次聚合的逻辑是：全部数据相乘起来
                        // 原理：第1次取前2个数据相乘，之后每次获取到的数据 = 返回的数据x原始下1个数据每
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer s) throws Exception {
                Log.e(TAG, "最终计算的结果是： "+s);

            }
        });

https://mp.weixin.qq.com/s/2vDZ7h6SL-LR7n3FR6OMrw