RxJava操作符(2)-变换

最新推荐文章于 2021-05-25 16:58:42 发布

dylanzhuang

最新推荐文章于 2021-05-25 16:58:42 发布

阅读量678

点赞数

分类专栏： rxjava 文章标签： rxjava 变换操作符

本文链接：https://blog.youkuaiyun.com/DylanZhuang/article/details/52165995

版权

rxjava 专栏收录该内容

9 篇文章

订阅专栏

本文深入探讨了RxJava中的变换操作符，包括Buffer, FlatMap, FlatMapIterable, ConcatMap, SwitchMap, GroupBy, Map, Cast, Scan和Window。通过原理图和示例代码，详细阐述了这些操作符的使用方法和应用场景。" 122474744,11806334,年度工作部署的激励金句100例,"['职场和发展', '经验分享', '程序人生']

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Buffer

Buffer操作符是将要发送的数据按照固定的大小进行新的封装，然后将这些封装好的数据在发射出去，发射出去的数据不是一个单独的数据，而是一个集成。

原理图如下：

Buffer操作符是将要发送的数据按照固定的大小进行新的封装，然后将这些封装好的数据在发射出去，发射出去的数据不是一个单独的数据，而是一个集成。其中的skip参数代表每发射一次数据，就跳过skip数据之后，进行新的数据封装，然后发射数据。

原理图如下：

Buffer操作符的使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        Observable observable = Observable.just(1, 2, 3, 4, 5, 6, 7, 8);
        if (mRandom == BufferDetailActivity.MAX) {
            mObservable = observable.buffer(2, 3);
        } else if (mRandom == BufferDetailActivity.MIN) {
            mObservable = observable.buffer(3);
        }
    }

运行代码，结果如下：

FlatMap

FlatMap操作符是将从Observable发射出的数据，按照一定的规则重新封装为一个新的Observable在发射出去。需要注意的是最后发射出去的数据有可能是交错的。

原理图如下：

FlatMap操作符的使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).flatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                return Observable.just(integer * 2);
            }
        });
    }

运行代码，结果如下：

FlatMapIterable

FlatMapIterable操作符基本是与FlatMap操作符一样，不同的地方是新的Observable发射出去的数据是以iterable作为数据源。

原理图如下：

FlatMapIterable操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).flatMapIterable(new Func1<Integer, Iterable<String>>() {
            @Override
            public Iterable call(Integer integer) {
                List<String> list = new ArrayList<String>();
                for (int i = 0; i < integer; i++) {
                    list.add("list" + i);
                }
                return list;
            }
        });
    }

运行代码。结果如下：

ConcatMap

ConcatMap操作符基本是与FlatMap操作符一样，不同的地方是新的Observable发射出去的出去的顺序不变。

原理图如下：

ConcatMap操作符的使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).concatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable call(Integer integer) {
                return Observable.just(integer * 2);
            }
        });
    }

运行代码，结果如下：

SwitchMap

SwitchMap操作符基本是与FlatMap操作符一样，不同的地方是当原始Observable发射一个新的数据（Observable）时，它将取消订阅并停止监视产生执之前那个数据的Observable，只监视当前这一个。

原理图如下：

SwitchMap操作符的使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).switchMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable call(Integer integer) {
                return Observable.just(integer * 2);
            }
        });
    }

运行代码，结果如下：

GroupBy

GroupBy操作符是将原Observable发射的数据，并通过一定规则生成的key，按照相同的key将发射出去的数据包含在一个小的Observable里，然后将这些小的Observable里的数据发射出去。该操作符类似于数据库里的groupBy字段。

原理图如下：

GroupBy操作符的使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5, 6).groupBy(new Func1<Integer, Integer>(){
            @Override
            public Integer call(Integer integer) {
                return integer % 2;
            }
        });
    }

运行代码，结果如下：

Map

Map操作符与FlatMap操作符比较类似，不同的是Map操作符对数据的变换是直接进行的，不用重新生成新的Observable。

原理图如下：

Map操作符的使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).map(new Func1<Integer, Integer>() {
            @Override
            public Integer call(Integer integer) {
                return integer * 2;
            }
        });
    }

运行代码，结果如下：

Cast

Cast操作符将Observable发射的数据强制转化为另外一种类型。

原理图如下：

Cast操作符的使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).cast(Integer.class);
    }

运行代码，结果如下：

Scan

Scan操作符操作符对原始Observable发射的第一项数据应用一个函数，然后将那个函数的结果作为自己的第一项数据发射。它将函数的结果同第二项数据一起填充给这个函数来产生它自己的第二项数据。它持续进行这个过程来产生剩余的数据序列。类似于迭代操作。

原理图如下：

Scan操作符的使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).scan(new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        });
    }

运行代码，结果如下：

Window

Window操作符类似于Buffer操作符，不同的是Window操作符每次发射出去的是Observable，而Buffer操作符发射出去的是一项数据。

原理图如下：

Window操作符的使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).window(3);
    }

运行代码，结果如下：