RxJava原理

• subscribeOn 是决定 observable 中产生数据的方法执行在哪个线程
• observeOn 是决定 observer 消费数据的方法执行在哪个线程

多个 subscribeOn 连着写，以第一个为准
多个 observeOn 连着写，以最后一个为准

Rxjava map和flatMap区别

map和flatMap都是依赖传入的Function对数据进行变换

RxJava 2.0

@SchedulerSupport(SchedulerSupport.NONE)
    public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
    }

  @SchedulerSupport(SchedulerSupport.NONE)
    public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) {
        return flatMap(mapper, false);
    }

1、返回值上面：
map变换后可以返回任意值，而flatMap则只能返回ObservableSource类型

2、变换后的输出：

map只能进行一对一的变换，而flatMap则可以进行一对一，一对多，多对多的变换，具体的变换规则根据我们设置的变换函数mapper来定

List<String> list = new ArrayList<>();
        list.add("b");
        list.add("a");
        list.add("c");
        System.out.println("1对1:[b, a, c]-->[b, a, c]");
        //1对1
        Observable.just(list)
                .flatMap(
                        new Function<List<String>, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(List<String> s) throws Exception {
//                                System.out.println("map--1----" + s);
                                return Observable.fromArray(s);
                            }
                        })
                .subscribe(s -> {
                    System.out.println(s);
                });
        System.out.println("1对多:[b, a, c]-->b, a, c");
        //1对多
        Observable.just(list)
                .flatMap(
                        new Function<List<String>, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(List<String> s) throws Exception {
//                                System.out.println("map--1----" + s);
                                return Observable.fromIterable(s);
                            }
                        })
                .subscribe(s -> {
                    System.out.println(s);
                });
 
        //1对多
        System.out.println("多对多:a, b, c-->[a, c]");
        Observable.just("a", "b", "c")
                .flatMap(
                        new Function<String, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(String s) throws Exception {
//                                System.out.println("map--1----" + s);
                                if (s.equalsIgnoreCase("b")) return Observable.empty();
                                return Observable.just(s);
                            }
                        })
                .subscribe(s -> {
                    System.out.println(s);
                });
 
        //1对多
        System.out.println("多对多:a, b, c-->a,b,c,d");
        Observable.just("a", "b", "c")
                .flatMap(
                        new Function<String, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(String s) throws Exception {
//                                System.out.println("map--1----" + s);
                                if (s.equalsIgnoreCase("c")) return Observable.just("c", "d");
                                return Observable.just(s);
                            }
                        })
                .subscribe(s -> {
                    System.out.println(s);
                });
        System.out.println("map 一对一:[b, a, c]-->[b, a, c]");
        Observable.just(list)
                .map(new Function<List<String>, List<String>>() {
                    @Override
                    public List<String> apply(List<String> strings) throws Exception {
                        return strings;
                    }
                })
                .subscribe(s -> {
                    System.out.println(s);
                });