RxJava操作符(4)-结合

最新推荐文章于 2024-06-05 10:08:47 发布

dylanzhuang

最新推荐文章于 2024-06-05 10:08:47 发布

阅读量723

点赞数

分类专栏： rxjava 文章标签： rxjava 结合操作符

本文链接：https://blog.youkuaiyun.com/DylanZhuang/article/details/52198387

版权

rxjava 专栏收录该内容

9 篇文章

订阅专栏

CombineLatest

CombineLatest操作符可以将2-9个Observable的数据组装起来然后在发射出去。2-9个Observable中的任何一个Observable发射出去的数据，都会和其它每个Observable发射出去的最近的数据，按照一定的函数规则进行组装，最后发射出去的是由这个函数组装完成的结果。

原理图如下：

CombineLatest操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.combineLatest(createObservable(1), createObservable(2), createObservable(3), new Func3() {
            @Override
            public Object call(Object o, Object o2, Object o3) {
                String message = "o = " + o + " o2 = " + o2 + " o3 = " + o3;
                displayLogcat(message);
                return (Integer)o + (Integer)o2 + (Integer)o3;
            }
        });
    }

    private Observable createObservable(final int index) {
        return Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (index == 2 || index == 3) {
                    try {
                        Thread.sleep((index - 1) * 333);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (int i = 1; i < 5; i++) {
                    subscriber.onNext(i * index);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                subscriber.onCompleted();
            }
        }).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread());
    }

运行代码，结果如下：

Join

Join操作符是组合两个Observable数据的，每个Observable都有一个时间区域，只有在这段时间区域内发射出去的数据才能被一定的函数规则组合起来，在发射出去。

原理图如下：

Join操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1).join(createObservable(2), new Func1<Integer, Observable<Long>>() {
            @Override
            public Observable<Long> call(Integer integer) {
                displayLogcat("first fun1 integer = " + integer);
                /**
                 * 返回的数据为当Observable.just(1)发射完毕后,在规定的3s内，
                 * createObservable(2)所发射出去的数据
                 */
                return Observable.timer(3, TimeUnit.SECONDS);
            }
        }, new Func1<Integer, Observable<Long>>() {
            @Override
            public Observable<Long> call(Integer integer) {
                displayLogcat("second fun1 integer = " + integer);
                return Observable.timer(1, TimeUnit.SECONDS);
            }
        }, new Func2() {
            @Override
            public Object call(Object o, Object o2) {
                displayLogcat("o = " + o + " o2 = " + o2);
                return (Integer) o + (Integer) o2;
            }
        });
    }

    private Observable createObservable(final int index) {
        return Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (index == 2) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (int i = 0; i < index; i++) {
                    subscriber.onNext(i + index);
                    if (index == 2) {
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                subscriber.onCompleted();
            }
        }).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread());
    }

运行代码，结果如下：

Merge

Merge操作符是将2-9个Observable组合起来，在发射出去，就像一个Observable发射数据一样，但是发射出去的数据可能是交错存在的。如果在合并的过程中抛出了一个onError，则数据发射就会结束，并将这个数据异常抛出来。

原理图如下：

Merge操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.merge(Observable.just(0, 2, 4, 5, 8), Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 1; i < 10; i+=2) {
                    if (i == 7) {
                        subscriber.onError(new Throwable("7"));
                    } else {
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                }
            }
        }));
    }

运行代码，结果如下：

MergeDelayError

MergeDelayError操作符跟Merge操作符基本上一样，只是在处理异常的时候有区别，MergeDelayError操作符会把异常在最后抛出,不会终止其它数据的合并。

原理图如下：

MergeDelayError操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.mergeDelayError(Observable.just(0, 2, 4, 5, 8), Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 1; i < 10; i+=2) {
                    if (i == 7) {
                        subscriber.onError(new Throwable("7"));
                    } else {
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                }
            }
        }));
    }

运行代码，结果如下：

StartWith

StartWith操作符是在原Observable的的前面插入数据，这些数据可为Iterable、Observable。

原理图如下：

StartWith操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(5, 6, 7)
                .startWith(Observable.just(1, 2 ,3, 4));
    }

运行代码，结果如下：

Switch

Switch操作符的api是switchOnNext，该操作符会发射一些列小的Observable，如果一个Observable发射出去的数据被其它Observable发射出去的数据覆盖掉了，则Switch操作符会丢弃掉被覆盖的数据，会将新的数据发射出去。

原理图如下：

Switch操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.switchOnNext(Observable.create(new Observable.OnSubscribe<Observable<String>>() {
            @Override
            public void call(Subscriber<? super Observable<String>> subscriber) {
                for (int i = 0; i < 2; i++) {
                    subscriber.onNext(createObservable(i));
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        })).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread());
    }

    private Observable<String> createObservable(final int index) {
        return Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                    subscriber.onNext(index + "_" + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).subscribeOn(Schedulers.newThread());
    }

运行代码，结果如下：

Zip

Zip操作符是将2-9个Observable的数据按照顺序组合起来，并且每个数据只能组合一次。最后Zip操作符发射出去数据的个数由2-9个Observable中最少的个数决定。

原理图如下：

Zip操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.zip(Observable.just(1, 2, 3, 4), Observable.just(5, 6, 7), new Func2() {
            @Override
            public Object call(Object o, Object o2) {
                return o + " - " +  o2;
            }
        });
    }

运行代码，结果如下：