rxjava : flatMap concatMap switchMap区别

参考：RxJava2 中容易混淆的函数

• map() ： 一般用于对原始的参数进行加工处理，返回值还是基本的类型，可以在subscribe中使用(适用)的类型。

• flatMap() ： 并行无序,一般用于输出一个Observable

• concatMap() ： concatMap()和flatMap()很像，但串行有序

• switchMap() ： switchMap()和flatMap()很像，除了一点:当源Observable发射一个新的数据项时，如果旧数据项订阅还未完成，就取消旧订阅数据和停止监视那个数据项产生的Observable,开始监视新的数据项；

测试一： 在不同线程

flatMap：【无序】
concatMap：【有序】
switchMap：当原始Observable发射一个新的数据时，它将取消订阅并停止监视产生执之前那个数据的Observable，只监视当前这一个

public void actionSwitchMap1() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Disposable disposable = Observable.fromIterable(list)
            .switchMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {

                    return Observable.just("integer=" + integer)
                            .subscribeOn(Schedulers.newThread()); //新线程
                }
            })
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println("switchMap accept=====" + s 
                    				+ Thread.currentThread().getName());
                }
            });
}
//switchMap 不同线程/并发：当上一个任务尚未完成时，就开始下一个任务的话，上一个任务就会被取消掉
//switchMap accept=====integer=9RxNewThreadScheduler-20




public void actionFlatMap1() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Disposable disposable = Observable.fromIterable(list)
            .flatMap(new Function<Integer, ObservableSource<String>>() {//flatMap ：无序
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    return Observable.just("integer=" + integer)
                            .subscribeOn(Schedulers.newThread());//新线程
                }
            })
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println("flatMap accept=====" + s 
                    			+ Thread.currentThread().getName());
                }
            });
}
//先完成-->先回调 （无序）
//flatMap accept=====integer=1RxNewThreadScheduler-2
//flatMap accept=====integer=3RxNewThreadScheduler-4
//flatMap accept=====integer=4RxNewThreadScheduler-4
//flatMap accept=====integer=5RxNewThreadScheduler-6
//flatMap accept=====integer=2RxNewThreadScheduler-3
//flatMap accept=====integer=7RxNewThreadScheduler-3
//flatMap accept=====integer=9RxNewThreadScheduler-3
//flatMap accept=====integer=8RxNewThreadScheduler-9
//flatMap accept=====integer=6RxNewThreadScheduler-9


public void actionConcatMap1() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Disposable disposable = Observable.fromIterable(list)
            .concatMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    return Observable.just("integer=" + integer)
                            .subscribeOn(Schedulers.newThread());//新线程
                }
            })
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println("concatMap accept=====" + s 
                    			+ Thread.currentThread().getName());
                }
            });
}
//先完成-->先回调 （有序）
//concatMap accept=====integer=1RxNewThreadScheduler-1
//concatMap accept=====integer=2RxNewThreadScheduler-12
//concatMap accept=====integer=3RxNewThreadScheduler-21
//concatMap accept=====integer=4RxNewThreadScheduler-22
//concatMap accept=====integer=5RxNewThreadScheduler-23
//concatMap accept=====integer=6RxNewThreadScheduler-24
//concatMap accept=====integer=7RxNewThreadScheduler-25
//concatMap accept=====integer=8RxNewThreadScheduler-26
//concatMap accept=====integer=9RxNewThreadScheduler-27

测试二：相同线程

在同一个线程里,flatMap,ContactMap,switchMap效果一样：先跑–>先回调（按发射顺序）

public void actionFlatMap2() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Disposable disposable = Observable.fromIterable(list)
            .flatMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    return Observable.just("integer=" + integer);
                }
            })
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println("flatMap accept=====" + s 
                    				+ Thread.currentThread().getName());
                }
            });
}
//flatMap accept=====integer=1main
//flatMap accept=====integer=2main
//flatMap accept=====integer=3main
//flatMap accept=====integer=4main
//flatMap accept=====integer=5main
//flatMap accept=====integer=6main
//flatMap accept=====integer=7main
//flatMap accept=====integer=8main
//flatMap accept=====integer=9main


public void actionConcatMap2() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Disposable disposable = Observable.fromIterable(list)
            .concatMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    return Observable.just("integer=" + integer);
                }
            })
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println("concatMap accept=====" + s 
                    			+ Thread.currentThread().getName());
                }
            });
}
//concatMap accept=====integer=1main
//concatMap accept=====integer=2main
//concatMap accept=====integer=3main
//concatMap accept=====integer=4main
//concatMap accept=====integer=5main
//concatMap accept=====integer=6main
//concatMap accept=====integer=7main
//concatMap accept=====integer=8main
//concatMap accept=====integer=9main


public void actionSwitchMap2() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Disposable disposable = Observable.fromIterable(list)
            .switchMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    return Observable.just("integer=" + integer);
                }
            })
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println("switchMap accept=====" + s 
                    				+ Thread.currentThread().getName());
                }
            });
}
//switchMap accept=====integer=1main
//switchMap accept=====integer=2main
//switchMap accept=====integer=3main
//switchMap accept=====integer=4main
//switchMap accept=====integer=5main
//switchMap accept=====integer=6main
//switchMap accept=====integer=7main
//switchMap accept=====integer=8main
//switchMap accept=====integer=9main

测试三：

public void actionFlatMap3() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Disposable disposable = Observable.fromIterable(list)
            .flatMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    return Observable.just("integer=" + integer)
                            .delay(5, TimeUnit.MILLISECONDS);
                }
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println("flatMap accept=====" + s 
                    				+ Thread.currentThread().getName());
                }
            });
}
//无序
//flatMap accept=====integer=1main
//flatMap accept=====integer=2main
//flatMap accept=====integer=3main
//flatMap accept=====integer=4main
//flatMap accept=====integer=6main
//flatMap accept=====integer=7main
//flatMap accept=====integer=5main
//flatMap accept=====integer=8main
//flatMap accept=====integer=9main

public void actionConcatMap3() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Disposable disposable = Observable.fromIterable(list)
            .concatMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    return Observable.just("integer=" + integer)
                            .delay(5, TimeUnit.MILLISECONDS);
                }
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println("concatMap accept=====" + s 
                    					+ Thread.currentThread().getName());
                }
            });
}
//有序
//concatMap accept=====integer=1main
//concatMap accept=====integer=2main
//concatMap accept=====integer=3main
//concatMap accept=====integer=4main
//concatMap accept=====integer=5main
//concatMap accept=====integer=6main
//concatMap accept=====integer=7main
//concatMap accept=====integer=8main
//concatMap accept=====integer=9main

public void actionSwitchMap3() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
    Disposable disposable = Observable.fromIterable(list)
            .switchMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    return Observable.just("integer=" + integer)
                            .delay(5, TimeUnit.MILLISECONDS);
                }
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) throws Exception {
                    System.out.println("switchMap accept=====" + s 
                    				+ Thread.currentThread().getName());
                }
            });
}
//当原始Observable发射一个新的数据时，它将取消订阅并停止监视产生之前那个数据的Observable，只监视当前这一个
//switchMap accept=====integer=9main