二、RxJava基础 ---转化操作（Transforming Observables）

最新推荐文章于 2021-02-26 21:52:03 发布

原创最新推荐文章于 2021-02-26 21:52:03 发布 · 410 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Buffer #map #Rxjava #flatMap

android Rxjava学习专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了RxJava中变换操作符的使用方法，包括Map、Buffer、FlatMap、GroupBy、Scan和Window等，通过具体示例展示了如何对Observable发射的数据进行转换、收集、分组和平坦化。

一、前言

上篇主要介绍了Observable 的创建方法，从本篇开始着重开始记录学习对Observable 操作的一些方法。

Transforming Observables 转换操作符
Filtering Observables 过滤操作符
Combining Observables 合并操作符

本篇先从转换操作符开始学习：

二、变换操作符 Transforming Observables

将由可观察到的项进行转换的操作符。

1、Map

对Observable发射的每一项数据都应用一个函数来变换。

 /**
     * map : 对Observable发射的每一项数据都应用一个函数来变换。
     */
    private static void mapTest() {
        Observable.just(2, 3, 4, 5, 6)
                .map(new Func1<Integer, String>() {//Func1 的参数1：入参 ，参数2：返回值
                    @Override
                    public String call(Integer integer) {
                       int temp = integer.intValue()+2;//转换为 int 每个 加2

                        return "submit ----> "+temp;
                    }
                }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted--->");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
              System.out.println("onNext--->"+s);
            }
        });

    }

2、Buffer

它定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个

/**
     * buffer 它定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个
     */
    private static void bufferTest(){
        Observable.just("1","2","3","4")
                //count 参数1 每次生产buffer list 的 size：
                // skip 参数2：在开始新 buffer 的之前，应该跳过源观察到的多少项
                .buffer(3,1)
                .subscribe(new Action1<List<String>>() {
                    @Override
                    public void call(List<String> strings) {

                        for (String string : strings) {
                            System.out.println("onNext--->"+string);
                        }
                        System.out.println("onNext--->list");
                    }
                });
        Observable
                .just(1,2,3,4,5)
                // timespan :每个缓冲区在发送之前收集项目的时间
                // timeshift : 一段时间后，将创建一个新的缓冲区  ？？？还是没明白如何使用
                .buffer(1,2, TimeUnit.SECONDS)
                .subscribe(new Action1<List<Integer>>() {
                    @Override
                    public void call(List<Integer> integers) {
                        for (Integer integer : integers) {
                            System.out.println("onNext--->"+integer);
                        }
                        System.out.println("onNext--->list");
                    }
                });
    }

3、FlatMap

将Observable发射的数据变换为Observables集合，然后将这些Observable发射的数据平坦化的放进一个单独的Observable，内部采用merge合并。

 /**
     * flatMap : 将Observable发射的数据变换为Observables集合，
     *          然后将这些Observable发射的数据平坦化的放进一个单独的Observable，
     *          内部采用merge合并。
     */
    public static void flatMapTest() {

        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("first");
                subscriber.onNext("first");
            }
        }).flatMap(new Func1<String, Observable<String>>() {
            @Override
            public Observable<String> call(String s) {

                return Observable.just(s+"---just");// ??? 为什么不走 onCompleted方法
             }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted--->");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError--->");
            }

            @Override
            public void onNext(String s) {
                System.out.println("onNext--->"+s);
            }
        });

        Observable
                .just(1, 2, 3)// 原始的
                .flatMap(new Func1<Integer, Observable<String>>() {
                    @Override
                    public Observable<String> call(final Integer integer) {
                        //新建的
                        Observable newObs = Observable.create(new Observable.OnSubscribe<String>() {
                            @Override
                            public void call(Subscriber<? super String> subscriber) {
                                int temp = integer.intValue() + 2;
                                subscriber.onNext(""+temp);
                            }
                        });
                        return newObs; //  返回
                    }
                }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted--->");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError--->");
            }

            @Override
            public void onNext(String s) {
                System.out.println("onNext--->"+s);
            }
        });
    }

4、groupBy

将Observable分拆为Observable集合，将原始Observable发射的数据按Key分组，每一个Observable发射一组不同的数据。

 /**
     * groupBy : 将Observable分拆为Observable集合，
     *          将原始Observable发射的数据按Key分组，
     *          每一个Observable发射一组不同的数据
     * 有毛用处？？？？         
     */
    private static void groupByTest() {
        Observable
                .just(1, 2, 3, 4, 5)
                .groupBy(new Func1<Integer, String>() {
                    @Override
                    public String call(Integer integer) {
                        int te = integer.intValue();
                        return te % 2 == 0 ? "oushu" : "jishu";
                    }
                }).subscribe(new Subscriber<GroupedObservable<String, Integer>>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(final GroupedObservable<String, Integer> gObservable) {
                gObservable.subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println("get:" + gObservable.getKey()+"----"+integer.toString());
                    }
                });
            }
        });
    }

5、scan

对Observable发射的每一项数据应用一个函数，然后按顺序依次发射每一个值。

 private static void scanTest(){
        Observable.just(1,2,3,4)
                .scan(new Func2<Integer, Integer, Integer>() {
                    @Override
                    public Integer call(Integer integer, Integer integer2) {
                        System.out.println("integer=="+integer+"---integer2--"+integer2);
                        return integer+integer2;
                    }
                }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("integer=="+integer);
            }
        });
    }

6、Window

定期的将来自Observable的数据分拆成一些Observable窗口，然后发射这些窗口，而不是每次发射一项。

Observable.just(2,3,5,6)
            .window(3)
            .subscribe(new Action1<Observable<Integer>>() {
                @Override
                public void call(Observable<Integer> integerObservable) {
                    integerObservable.subscribe(new Action1<Integer>() {
                        @Override
                        public void call(Integer integer) {

                        }
                    });
                }
            })