Rx 入门（五）-- 转换操作符

RxJava 操作符官方文档，一共有一下五种：

• Map
• FlatMap
• GroupBy
• Scan
• Window

本文主要讲 map 和 flapMap ，其它的用到时候看文档就好了

Map 操作符

最基础的转换函数就是 map。 map 使用一个转换的参数把源Observable 中的数据转换为另外一种类型的数据。返回的 Observable 中包含了转换后的数据。

public final <R> Observable<R> map(Func1<? super T,? extends R> func)

Func1 的源码为

public interface Func1<T,R> extends Function{
    R call(T t);
}

源码可看出要传进去两个参数：T 决定了 call 方法 的参数类型，R 决定了返回值类型

/**
     * Map
     * 
     * 通过使用map中的方法对Observable中发射出来的所有数据进行变换
     * 
     * test1()方法是得到多个Student对象中的name，保存到nameList中 注意：接口Func1包装的是有返回值的方法。
     */
    private static void test1() {
        List<String> nameList = new ArrayList<>();
        Observable.from(studentList).map(new Func1<Student, String>() {

            @Override
            public String call(Student student) {
                return student.name;
            }
        }).subscribe(new Subscriber<String>() {

            @Override
            public void onCompleted() {
                System.out.println("onCompleted nameList.size() = " + nameList.size());
            }

            @Override
            public void onNext(String value) {
                System.out.println("onSuccess value = " + value);
                nameList.add(value);
            }

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

    }

Flatmap操作符

FlatMap将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable

public final <R> Observable<R> flatMap(Func1<? super T,? extends Observable<? extends R>> func)

    /**
     * Flatmap操作符
     * FlatMap将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable
     * 
     * FlatMap是一个用处很大的操作符，可以将要数据根据你想要的规则进行转化后再发射出去。
     * 其原理就是将这个Observable转化为多个以原Observable发射的数据作为源数据的Observable，
     * 然后再将这多个Observable发射的数据整合发射出来，需要注意的是最后的顺序可能会交错地发射出来，
     * 如果对顺序有严格的要求的话可以使用concatmap操作符。
     * FlatMapIterable和FlatMap基本相同，不同之处为其转化的多个Observable是使用Iterable作为源数据的。
     * 参考：http://blog.csdn.net/jdsjlzx/article/details/51493552
     */
    private static void test3() {
        List<String> nameList = new ArrayList<>();
        Observable.from(studentList).flatMap(new Func1<Student, Observable<Course>>() {

            @Override
            public Observable<Course> call(Student t) {
                Course course = couseMap.get(t.name);
                return Observable.just(course);
            }
        }).subscribe(new Subscriber<Course>() {

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

            @Override
            public void onNext(Course course) {
                System.out.println("onSuccess course = " + course);
            }

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

    }

    /**
     * FlatMap操作符
     * FlatMap将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable
     */
    private static void test4() {
        List<String> nameList = new ArrayList<>();
        Observable.from(studentList).flatMap(new Func1<Student, Observable<Entity>>() {

            @Override
            public Observable<Entity> call(Student student) {
                Course course = couseMap.get(student.name);
                Entity entity = new Entity(course, student);
                return Observable.just(entity);
            }
        }).subscribe(new Subscriber<Entity>() {

            @Override
            public void onCompleted() {
            }

            @Override
            public void onNext(Entity entity) {
                System.out.println("onSuccess entity = " + entity);
            }

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

    }

ConcatMap操作符

类似于最简单版本的flatMap，但是它按次序连接而不是合并那些生成的Observables，然后产生自己的数据序列。

private static void test5() {
        Observable.from(studentList).concatMap(new Func1<Student, Observable<Course>>() {

            @Override
            public Observable<Course> call(Student t) {
                Course course = couseMap.get(t.name);
                return Observable.just(course);
            }
        }).subscribe(new Subscriber<Course>() {

            @Override
            public void onCompleted() {
            }

            @Override
            public void onNext(Course course) {
                System.out.println("onSuccess course = " + course);
            }

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

flatMap与ConcatMap操作符比较 区别

/**
     * flatMap与ConcatMap操作符比较 区别：
     * 无序：FlatMap对这些Observables发射的数据做的是合并(merge)操作，因此它们可能是交错的。
     * 有序：ConcatMap不会让变换后的Observables发射的数据交错，它按照严格的顺序发射这些数据。
     * 
     * 说明：在同步线程中，FlatMap和ConcactMap的执行结果是一样的（结果是有序的），
     * 只有在异步线程中，FlatMap结果可能是无序的，而ConcactMap始终能保持有序的结果。
     * 
     * concatMap与flatMap操作符的比较
     * 参见：http://blog.csdn.net/jdsjlzx/article/details/51508852
     */
    private static void test6() {
        List<Integer> numbers = Arrays.asList(2, 3, 4, 5, 6, 7, 8, 9, 10);
        Observable.from(numbers).flatMap(new Func1<Integer, Observable<Integer>>() {

            @Override
            public Observable<Integer> call(Integer t) {
                return Observable.just(t).subscribeOn(Schedulers.from(Executors.newCachedThreadPool()));
                // return Observable.just(t);
            }
        }).subscribe(new Subscriber<Integer>() {

            @Override
            public void onCompleted() {
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("flatMap onSuccess value = " + value);
            }

            @Override
            public void onError(Throwable error) {
                System.out.println("onError error = " + error);
            }
        });
        System.out.println("----------------------------");
        Observable.from(numbers).concatMap(new Func1<Integer, Observable<Integer>>() {

            @Override
            public Observable<Integer> call(Integer t) {
                return Observable.just(t).subscribeOn(Schedulers.from(Executors.newCachedThreadPool()));
                // return Observable.just(t);
            }
        }).subscribe(new Subscriber<Integer>() {

            @Override
            public void onCompleted() {
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("concatMap onNext value = " + value);
            }

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

switchMap

/**
     * switchMap 解释：将Observable发射的数据集合变换为Observables集合，然后只发射这些Observables最近发射的数据
     * 用法与FlatMap几乎一样，区别是SwitchMap操作符只会发射[emit]最近的Observables。
     * 
     * 当源Observable发射一个新的数据项时，如果旧数据项订阅还未完成，就取消旧订阅数据和停止监视那个数据项产生的Observable,
     * 开始监视新的数据项.
     * 
     * 应用场景：http://blog.csdn.net/jdsjlzx/article/details/51730162
     * 
     * 逻辑推演： A --> 取消空的，没有可以取消的 B--> A1被取消 C--> B1被取消 D--> C1被取消 E--> D1被取消
     * 最终输出E1
     */
    private static void test7() {
        Observable.just("A", "B", "C", "D", "E").switchMap(new Func1<String, Observable<String>>() {
            @Override
            public Observable<String> call(String s) {
                return Observable.just(s + "1").subscribeOn(Schedulers.newThread()); // 并发
                // return Observable.just(s+"1");
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onCompleted() {
                System.out.println("switchMap onCompleted");
            }

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

            @Override
            public void onNext(String s) {
                System.out.println("switchMap Next :" + s);
            }
        });

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

switchMap与flatmap的区别

/**
     * switchMap与flatmap的区别
     * 
     * 说明：在同步线程中，switchMap发射[emit]所有的Observables，
     * 在异步线程中，switchMap只会发射[emit]最近的Observables。
     * 
     */
    private static void test8() {
        ExecutorService service = Executors.newFixedThreadPool(10);
        List<Integer> numbers = Arrays.asList(2, 3, 4, 5, 6, 7, 8, 9, 10);
        Observable.from(numbers).flatMap(new Func1<Integer, Observable<Integer>>() {

            @Override
            public Observable<Integer> call(Integer t) {
                return Observable.just(t).subscribeOn(Schedulers.from(service));
                // return Observable.just(t);
            }
        }).subscribe(new Subscriber<Integer>() {

            @Override
            public void onCompleted() {
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("flatMap onNext value = " + value);
            }

            @Override
            public void onError(Throwable error) {
                System.out.println("onError error = " + error);
            }
        });
        System.out.println("----------------------------------");
        Observable.from(numbers).switchMap(new Func1<Integer, Observable<Integer>>() {

            @Override
            public Observable<Integer> call(Integer t) {
                return Observable.just(t).subscribeOn(Schedulers.from(service));
                // return Observable.just(t);
            }
        }).subscribe(new Subscriber<Integer>() {

            @Override
            public void onCompleted() {
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("switchMap2 onNext value = " + value);
            }

            @Override
            public void onError(Throwable error) {
                System.out.println("onError error = " + error);
            }
        });
        service.shutdown();
    }