RxJava系列之常用变换操作符

最新推荐文章于 2020-01-06 16:04:13 发布

csdn_Mew

最新推荐文章于 2020-01-06 16:04:13 发布

阅读量258

点赞数

文章标签： Android RxJava

本文链接：https://blog.csdn.net/CSDN_Mew/article/details/103856780

版权

android 专栏收录该内容

86 篇文章 5 订阅

订阅专栏

系列文章

变换操作符

在上游发射的事件经过操作之后再发射给下游。相当于在上游与下游之间再做处理。例如map操作符的逻辑如下图所示：
在这里插入图片描述

map

map操作符，可以对

  /**
     * map 变换 操作符
     * @param view
     */
    public void r01(View view) {

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

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

                return "【" + integer + "】";
            }
        })
                
        .map(new Function<String, Bitmap>() {
            @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<Bitmap>() {
                    @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() {

                    }
                }

        );

    }

flatMap

在这里插入图片描述

对 Observable 发射的数据都应用(apply)一个函数，这个函数返回一个 Observable，然后合并这些Observables，并且发送（emit）合并的结果。 flatMap 和 map 操作符很相像，flatMap 发送的是合并后的Observables，map 操作符发送的是应用函数后返回的结果集。

 /**
     * flatMap 变换 操作符
     * @param view
     */
    public void r02(View view) {

        // 上游
        Observable.just(1111)

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

                // integer == 111

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

        // 订阅
        .subscribe(

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

    }

flatMap 是无序的，最终的观察者不会按照“步惊云”，“雄霸”，“李四”这样的顺序输出。

 /**
     * 体现 flatMap 变换 操作符 是不排序的
     * @param view
     */
    public void r03(View view) {

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

        .flatMap(new Function<String, ObservableSource<?>>() { // ? 通配符 默认Object
            @Override
            public ObservableSource<?> apply(String s) throws Exception {
                List<String> 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 Consumer<Object>() { // 下游
            @Override
            public void accept(Object s) throws Exception {
                Log.d(TAG, "下游 accept: " + s);
            }
        }*/

                new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

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

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                }

        );

    }

concatMap

concatMap 与flatMap功能差不多，但是concatMap 是有序的。

 /**
     * 体现 concatMap 变换操作符 排序的
     * @param view
     */
    public void r04(View view) {

        // 上游
        Observable.just("A", "B", "C")


                // 变换操作符
                .concatMap(new Function<String, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(String s) throws Exception {
                        List<String> 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 Consumer<Object>() { // 下游
                    @Override
                    public void accept(Object s) throws Exception {
                        Log.d(TAG, "accept: " + s);
                    }
                });



    }

groupBy

groupBy会将上游的数据根据条件分成组，会返回被观察者给下游，从而按照分组获取到上游传递的数据。类似于将数据分成几个组，每组中有多条数据。

  /**
     * 分组变换 groupBy
     * @param view
     */
    public void r05(View view) {

        // 上游
        Observable.just(6000, 7000, 8000, 9000, 10000, 14000)

         // 变换
        .groupBy(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return integer > 8000 ? "高端配置电脑" : "中端配置电脑"; // 分组
            }
        })

        // 订阅 这么写不行
        /*.subscribe(new Consumer<String>() { // 下游 使用 groupBy
            @Override
            public void accept(String string) throws Exception {

            }
        });*/

        // 使用groupBy下游是 有标准的
        .subscribe(new Consumer<GroupedObservable<String, Integer>>() {
            @Override
            public void accept(final GroupedObservable<String, Integer> groupedObservable) throws Exception {
                Log.d(TAG, "accept: " + groupedObservable.getKey());
                // 以上还不能把信息给打印全面，只是拿到了，分组的key

                // 输出细节，还需要再包裹一层
                // 细节 GroupedObservable 被观察者
                groupedObservable.subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "accept: 类别：" + groupedObservable.getKey() + "  价格：" + integer);
                    }
                });
            }
        });
    }

buffer

将上游发射的数据分批次发送到下游，下游将需要用List接收。

/**
     * 很多的数据，不想全部一起发射出去，分批次，先缓存到Buffer
     * @param view
     */
    public void r06(View view) {
        // 上游
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for (int i = 0; i < 100; i++) {
                    e.onNext(i);
                }
                e.onComplete();
            }
        })

        // 变换 buffer
        .buffer(20)

        .subscribe(new Consumer<List<Integer>>() {
            @Override
            public void accept(List<Integer> integer) throws Exception {
                Log.d(TAG, "accept: " + integer);
            }
        });
    }

总结

上游 -------> 变换操作(往右边流向的时候，进行变换) ----------> 下游
1.map 把上一层Int Int变换String 观察者String类型。

2.flatMap 把上一层Int Int变换ObservableSource{还可以再次发射多次事件} 观察者String类型。不排序的

3.concatMap 把上一层Int Int变换ObservableSource{还可以再次发射多次事件} 观察者Bitmap类型。排序的

4.groupBy 把上一层Int Int变换String(高端配置电脑) 观察者GroupedObservable类型 {key=“高端”, 细节再包裹一层}

5.buffer 100个事件 Integer .buffer(20) 观察者List==五个集合

csdn_Mew

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava系列之常用变换操作符

变换操作符在上游发射的事件经过操作之后再发射给下游。相当于在上游与下游之间再做处理。例如map操作符的逻辑如下图所示：map /** * map 变换操作符 * @param view */ public void r01(View view) { // 上游 Observable.just(1) // 发射 1...
复制链接

扫一扫