走进RxJava源码(四) -- 变换型操作符

变换型操作符

map操作符

 // 上游
        Observable.just(1) // 发射 1

        // 在上游和下游之间 变换
        .map(new Function() {
            @Override
            public String apply(Integer integer) throws Exception {
                // 1
                Log.d(TAG, "map1 apply: " + integer);

                return "【" + integer + "】";
            }
        })
                
        .map(new Function() {
            @Override
            public Bitmap apply(String s) throws Exception {
                // s == 【" + integer + "】
                Log.d(TAG, "map2 apply: " + s);
                return Bitmap.createBitmap(1920, 1280, Bitmap.Config.ARGB_8888);

                // return null; // 如果返回null，下游无法接收
            }
        })

        // 订阅
        .subscribe(

                // 下游
                new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Bitmap string) {
                        Log.d(TAG, "下游 onNext: " + string);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                }

        );

输入是Integer类型通过map的变换，变成String类型，然后再变换成Bitmap类型，下游最终接收的是Bitmap类型。
map操作符是一个比较"单一"的操作符(这个是和flatMap进行对比)，从Integer -> String -> Bitmap，都是一个类型转换位另外一个类型，类似一对一的情况，flatMap是变换为一个用ObservableSource包裹的类型。

flatMap操作符

        // 上游
        Observable.just(1111)

        // 变换操作符
        .flatMap(new Function>() {
            @Override
            public ObservableSource apply(final Integer integer) throws Exception {

                // integer == 111

                // ObservableSource == 可以再次手动发送事件
                return Observable.create(new ObservableOnSubscribe() {
                    @Override
                    public void subscribe(ObservableEmitter e) throws Exception {
                        e.onNext(integer + "flatMap变换操作符");
                        e.onNext(integer + "flatMap变换操作符");
                        e.onNext(integer + "flatMap变换操作符");
                    }
                });
            }
        })

        // 订阅
        .subscribe(

                // 下游
                new Consumer() {
                    @Override
                    public void accept(String string) throws Exception {
                        Log.d(TAG, "下游接收 变换操作符 发射的事件 accept: " + string);
                    }
        });

上游输入一个Integer类型，通过flatMap变换，最终下游接收的是三个String类型，这类似一对多的关系，通常用在上游是List集合类型，通过flatMap遍历Item给下游接收。

有一点需要注意的是flatMap操作符是无序的，不按顺序发射。

 // 上游
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext("步惊云"); // String
                e.onNext("雄霸");
                e.onNext("李四");
                e.onComplete();
            }
        })

        .flatMap(new Function>() { // ? 通配符 默认Object
            @Override
            public ObservableSource apply(String s) throws Exception {
                List list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add(s + " 下标：" + (1 + i));
                }
                return Observable.fromIterable(list).delay(5, TimeUnit.SECONDS); // 创建型操作符，创建被观察者
            }
        })

        // 订阅
        .subscribe(
                new Observer