Rxjava 合并操作符

组合 多个被观察者（Observable） & 合并需要发送的事件

1 startWith

在一个被观察者发送事件前，追加发送一些数据 / 一个新的被观察者

 @Test
    public void testStartWith() throws Exception {
        Observable.just(4, 5, 6)
                .startWith(Observable.just(7, 8, 9))
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println(integer);
                    }
                });
    }

7
8
9
4
5
6

---

2 concat

该类型的操作符的作用 = 组合多个被观察者

组合多个被观察者一起发送数据，合并后 按发送顺序串行执行

concat（） / concatArray（）二者区别：组合被观察者的数量，即concat（）组合被观察者数量≤4个，而concatArray（）则可＞4个

 @Test
    public void testConcat() throws Exception {
//        concat  最多四个
        Observable.concat(Observable.just(1, 2, 3), Observable.just(1, 2, 3), Observable.just(4, 5, 6))
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println(integer);
                    }
                });
    }

1
2
3
1
2
3
4
5
6

---

3 merge

组合多个被观察者一起发送数据，合并后 按时间线并行执行

merge（） / mergeArray（）二者区别：组合被观察者的数量，即merge（）组合被观察者数量≤4个，而mergeArray（）则可＞4个

区别上述concat（）操作符：同样是组合多个被观察者一起发送数据，但concat（）操作符合并后是按发送顺序串行执行

  @Test
    public void testMerge() throws Exception {
        Observable observable1 = Observable.just(1, 2, 3);

        Observable observable2 = Observable.just(6, 7, 8);
        Observable observable3 = Observable.just(0, 0, 0);

        Observable.merge(observable1, observable3, observable2).subscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                System.out.println(o);
            }
        });
    }

1
2
3
0
0
0
6
7
8

---

4 concatDelayError

    @Test
    public void testConcatDelayError() {

        //无使用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) {
                        System.out.println("接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("对Error事件作出响应");
                        System.out.println("===============================");
                    }

                    @Override
                    public void onComplete() {
                        System.out.println("对Complete事件作出响应");
                    }
                });

		//使用了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) {
                        System.out.println("接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        System.out.println("对Complete事件作出响应");
                    }
                });
    }

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

5 zip

合并 多个被观察者（Observable）发送的事件，生成一个新的事件序（即组合过后的事件序列），并最终发送

事件组合方式 = 严格按照原先事件序列 进行对位合并
最终合并的事件数量 = 多个被观察者（Observable）中数量最少的数量

  @Test
    public void testZip() throws Exception {
        Observable.zip(Observable.just(1, 2, 3)//6  9
                , Observable.just(4, 5, 6), new BiFunction<Integer, Integer, Object>() {
                    @Override
                    public Object apply(Integer integer, Integer integer2) throws Exception {
                        return integer + integer2;
                    }
                }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                System.out.println("" + o);
            }
        });


    }

5
7
9