rxjava : concat merge zip

最新推荐文章于 2024-07-06 03:39:16 发布

Mars-xq

最新推荐文章于 2024-07-06 03:39:16 发布

阅读量745

点赞数

分类专栏： rxjava

本文链接：https://blog.csdn.net/sinat_31057219/article/details/101109459

版权

rxjava 专栏收录该内容

52 篇文章 3 订阅

订阅专栏

merge()		： 并行无序
concat()	： 串行有序
amb()		： 先发才收，其他不收
zip()		： 有序，不完全（以最少数量）

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

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

测试1

//concat
//将两个发射器合并成一个发射器, 依次发送，发送完一个再接着发送第二个
public void concat2() {
    Observable<Long> observable1 = Observable.intervalRange(0,
            6, 1, 1, TimeUnit.SECONDS);
    Observable<Long> observable2 = Observable.intervalRange(8,
            5, 2, 1, TimeUnit.SECONDS);
    Disposable disposable = Observable.concat(observable1, observable2)
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    System.out.println("concat=================" + aLong);
                }
            });
}
//concat=================0
//concat=================1
//concat=================2
//concat=================3
//concat=================4
//concat=================5
//concat=================8
//concat=================9
//concat=================10
//concat=================11
//concat=================12


//merge ：交叉合并 , 
//将多个ObservableSources展平为单个ObservableSource，无需进行任何转换。
public void merge2() {
    Observable<Long> observable1 = Observable.intervalRange(0,
            6, 1, 1, TimeUnit.SECONDS);
    Observable<Long> observable2 = Observable.intervalRange(8,
            5, 2, 1, TimeUnit.SECONDS);
    Disposable disposable = Observable.merge(observable1, observable2)
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    System.out.println("merge=================" + aLong);
                }
            });
}
//merge=================0
//merge=================1
//merge=================8
//merge=================2
//merge=================9
//merge=================3
//merge=================10
//merge=================4
//merge=================11
//merge=================5
//merge=================12

测试2

/**
 * concat ： 
 *  将两个发射器合并成一个发射器, 依次发送，发送完一个再接着发送第二个
 */
public void concat() throws Exception {
    Observable<Integer> observable1 = ObservableHelper.getObservable1();
    Observable<String> observable2 = ObservableHelper.getObservable2();
    Observable<String> observable3 = ObservableHelper.getObservable3();
    Observable<? extends Serializable> observable = Observable.concat(observable1, 
													    observable2, 
													    observable3);
    observable.subscribe(ObserverHelper.getSerializableObserver());
}
//onNext serializable==============1
//onNext serializable==============2
//onNext serializable==============3
//onNext serializable==============4

/**
 * merge ：交叉合并
 * 将多个ObservableSources展平为单个ObservableSource，无需进行任何转换。
 */
public void merge() throws Exception {
    Observable<Integer> observable1 = ObservableHelper.getObservable1();
    Observable<String> observable2 = ObservableHelper.getObservable2();
    Observable<String> observable3 = ObservableHelper.getObservable3();
    Observable<? extends Serializable> observable = Observable.merge(observable1, 
   														 observable2, observable3);
    observable.subscribe(ObserverHelper.getSerializableObserver());
}
//onNext serializable==============1
//onNext serializable==============2
//onNext serializable==============3
//onNext serializable==============4
//onNext serializable==============一
//onNext serializable==============二
//onNext serializable==============三
//onNext serializable==============①
//onNext serializable==============②
//onNext serializable==============③
//onNext serializable==============④
//onNext serializable==============⑤
//onNext serializable==============⑥

/**
 * zip:组装Observable：有序，不完全（以最少数量）
 * 使用一个函数组合多个Observable发射的数据集合，然后再发射这个结果
 */
public void zip() throws Exception {
    Observable<Integer> observable1 = ObservableHelper.getObservable1();
    Observable<String> observable2 = ObservableHelper.getObservable2();
    Observable<String> observable3 = ObservableHelper.getObservable3();
    Observable<? extends Serializable> observable = Observable.zip(observable1, 
    													observable2, observable3,
            new Function3<Integer, String, String, Serializable>() {
                @Override
                public Serializable apply(Integer integer, String s, String s2) 
                								throws Exception {
                    return integer + "+" + s + "+" + s2;
                    //将上游数据遍历后组合，以最少的数量为主
                }
            });
    observable.subscribe(ObserverHelper.getSerializableObserver());
}
//onNext serializable==============1+一+①
//onNext serializable==============2+二+②
//onNext serializable==============3+三+③

ObserverHelper

public class ObserverHelper {

    public static Observer<Serializable> getSerializableObserver() {
        return new Observer<Serializable>() {

            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Serializable serializable) {
                System.out.println("onNext serializable==============" + serializable);
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError e==============" + e.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("onComplete==============");
            }
        };
    }

    public static Observer<String> getStringObserver() {
        return new Observer<String>() {

            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                System.out.println("onNext s==============" + s + " : " 
                									+ Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError e==============" + e.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("onComplete==============");
            }
        };
    }

    public static Consumer<Serializable> getConsumer() {
        return new Consumer<Serializable>() {

            @Override
            public void accept(Serializable serializable) throws Exception {
                System.out.println("accept serializable==============" 
                									+ serializable);
            }
        };
    }

}

ObservableHelper

public class ObservableHelper {

    public static Observable<Integer> getObservable1() {
        return Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onNext(4);
            }
        });
    }

    public static Observable<String> getObservable2() {
        return Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("一");
                emitter.onNext("二");
                emitter.onNext("三");
            }
        });
    }

    public static Observable<String> getObservable3() {
        return Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("①");
                emitter.onNext("②");
                emitter.onNext("③");
                emitter.onNext("④");
                emitter.onNext("⑤");
                emitter.onNext("⑥");
            }
        });
    }

    //just
    public static Observable<Integer> getObservable4() {
        return Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9);
    }

    //fromArray
    public static Observable<int[]> getObservable5() {
        return Observable.fromArray(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9});
    }

    //fromIterable
    public static Observable<Integer> getObservable6() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        return Observable.fromIterable(list);
    }

    //====== start ==========
    public static Observable<Integer> getObservable() {
        return Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 10000; i++) {
                    emitter.onNext(i);
                }
            }
        });
    }

    //map
    public static Observable<String> getMapObservable() {
        Observable<Integer> observable = getObservable();
        return observable.map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "map(Integer-->String)===" + integer;
            }
        });
    }

    //flatMap
    public static Observable<String> getFlatMapObservable() {
        Observable<Integer> observable = getObservable();
        return observable.flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                return action(integer, "flatMap(Integer-->Observable)===");
            }
        });
    }

    //concatMap
    public static Observable<String> getConcatMapObservable() {
        Observable<Integer> observable = getObservable();
        return observable.concatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                return action(integer, "concatMap(Integer-->Observable)===");
            }
        });
    }

    //concatMapEager
    public static Observable<String> getConcatMapEagerObservable() {
        Observable<Integer> observable = getObservable();
        return observable.concatMapEager(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                return action(integer, "concatMapEager(Integer-->Observable)===");
            }
        });
    }

    //switchMap
    public static Observable<String> getSwitchMapObservable() {
        Observable<Integer> observable = getObservable();
        return observable.switchMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                return action(integer, "switchMap(Integer-->Observable)===");
            }
        });
    }

    public static Observable<String> action(Integer integer, String s) {
        final List<String> list = new ArrayList<>();
        list.add(s + integer);

        int delay = 0;
        if (integer % 10 == 0) {
            delay = 500;
        }
        return Observable.fromIterable(list).delay(delay, TimeUnit.MILLISECONDS);
    }
    //========= end ==============

}