Android RxJava:图文详解 变换操作符

前言

  • Rxjava,由于其根据事件流的链式调用、逻辑简洁 &
    使用简便
    的特点,深受各大 Android开发者的接。

Github截图

一经还免了解 RxJava,请圈文章:Android:这是一致首 清晰 &
易懂的Rxjava 入门教程

  • RxJava这么被欢迎的因由,在于那供了增长 &
    功能强大的操作符,几乎会到位有着的成效要求
  • 今,我以为大家详细介绍RxJava操作符中最好常用的改换操作符,并附带
    Retrofit 结合 RxJava的实例Demo教学,希望你们会喜欢。
  1. 按部就班系列文章要依据 Rxjava 2.0
  2. 联网下去的流年,自身将随地推出 AndroidRxjava 2.0
    的一致密密麻麻文章,包括原理、操作符、应用场景、背压等等

    ,有趣味可以继承关注Carson_Ho的安卓开发笔记!!

示意图


目录

示意图


1. 作用

  • 针对事件序列中之波 / 整个事件序列
    进行加工处理(即变换),使得那变化成为不同之风波 / 整个事件序列
  • 实际原理如下

示意图


2. 类型

  • RxJava遭逢广的换操作符如下:

    示意图

  • 下面,我以针对每种操作符进行详尽介绍

注:本文仅讲解RxJava2在支付进程中常用之变换操作符


3. 应用场景 & 对应操作符 介绍

  • 下面,我将对 RxJava2 中之换操作符进行逐讲解
  • 注:在使用RxJava 2操作符前,记得在档次之Gradle中添加依赖:

dependencies {
      compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
      compile 'io.reactivex.rxjava2:rxjava:2.0.7'
      // 注:RxJava2 与 RxJava1 不能共存,即依赖不能同时存在
}

3.1 Map()

  • 作用
    对 被观察者发送的各1独事件还经 点名的函数
    处理,从而变换成另外一种事件

即, 用吃观察者发送的波转换为随意的项目事件。

  • 原理

示意图

  • 行使场景
    数据类型转换

  • 具体以
    下坐用 使用Map() 将事件的参数从 整型 变换成 字符串类型
    为例说明

示意图

 // 采用RxJava基于事件流的链式操作
        Observable.create(new ObservableOnSubscribe<Integer>() {

            // 1. 被观察者发送事件 = 参数为整型 = 1、2、3
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);

            }
            // 2. 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换:整型变换成字符串类型
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "使用 Map变换操作符 将事件" + integer +"的参数从 整型"+integer + " 变换成 字符串类型" + integer ;
            }
        }).subscribe(new Consumer<String>() {

            // 3. 观察者接收事件时,是接收到变换后的事件 = 字符串类型
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
  • 测试结果

示意图

自地方可以观看,map() 将参数中的 Integer 类型对象转换成一个
String类型 对象后返

再就是,事件之参数类型也出于 Integer 类型变成了 String 类型


3.2 FlatMap()

  • 企图:将吃观察者发送的事件序列进行 拆分 &
    单独转换
    ,再统一成为一个新的轩然大波序列,最后重复拓展发送

  • 原理

  • 也事件序列中每个事件都创一个 Observable 对象;

  • 拿本着每个 原始事件 转换后底 新事件 都放入到对应 Observable对象;
  • 用新建的每个Observable 都合并到一个 新建的、总的Observable
    对象;
  • 新建的、总的Observable 对象 将 新合并的风波序列
    发送给观察者(Observer

示意图

  • 采用场景
    无序的拿给观察者发送的整整事件序列进行更换

  • 现实以

// 采用RxJava基于事件流的链式操作
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }

            // 采用flatMap()变换操作符
        }).flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("我是事件 " + integer + "拆分后的子事件" + i);
                    // 通过flatMap中将被观察者生产的事件序列先进行拆分,再将每个事件转换为一个新的发送三个String事件
                    // 最终合并,再发送给被观察者
                }
                return Observable.fromIterable(list);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
  • 测试结果
示意图

注:新合并生成的轩然大波序列顺序是无序的,即 与老序列发送事件之次第无关

3.3 ConcatMap()

  • 作用:类似FlatMap()操作符

  • FlatMap()的 区别在于:拆分 & 重新联合生成的轩然大波序列 的逐一 =
    被观察者旧序列生产的一一

  • 原理

示意图

  • 应用场景
    一如既往的将吃观察者发送的周事件序列进行更换

  • 具体用

// 采用RxJava基于事件流的链式操作
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }

            // 采用concatMap()变换操作符
        }).concatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("我是事件 " + integer + "拆分后的子事件" + i);
                    // 通过concatMap中将被观察者生产的事件序列先进行拆分,再将每个事件转换为一个新的发送三个String事件
                    // 最终合并,再发送给被观察者
                }
                return Observable.fromIterable(list);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
  • 测试结果
示意图

注:新合并生成的轩然大波序列顺序是有序的,即 严格按原有序列发送事件之一一


3.4 Buffer()

  • 作用
    为期从 被观察者(Obervable)需要发送的事件受到 获取一定数额之风波 &
    放到缓存区中,最终发送

  • 原理

示意图

  • 使用场景
    缓存被观察者发送的轩然大波

  • 实际采用
    那么,Buffer()历次是得到多少只事件放到缓存区中的也?下面我将透过一个事例来证明

// 被观察者 需要发送5个数字
        Observable.just(1, 2, 3, 4, 5)
                .buffer(3, 1) // 设置缓存区大小 & 步长
                                    // 缓存区大小 = 每次从被观察者中获取的事件数量
                                    // 步长 = 每次获取新事件的数量
                .subscribe(new Observer<List<Integer>>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(List<Integer> stringList) {
                        //
                        Log.d(TAG, " 缓存区里的事件数量 = " +  stringList.size());
                        for (Integer value : stringList) {
                            Log.d(TAG, " 事件 = " + value);
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应" );
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
  • 测试结果

示意图

  • 经过解释

下,我拿经过一个图来诠释Buffer()原理 & 整个例子的结果

示意图

至此,关于RxJava2面临要的易操作符已经教结束


4. 实在支出需要案例

  • 改换操作符的重中之重支出需求场景 = 嵌套回调(Callback hell
  • 下面,我拿运用一个事实上应用场景实例来讲课嵌套回调(Callback hell

实际求看文章Android RxJava
实际行使案例教学:网络要嵌套回调


5. Demo地址

上述所有的Demo源代码都存放于:Carson_Ho的Github地址:RxJava2_更换操作符

喜爱的麻烦点个star


6. 总结

  • 下面,我拿就此同一张图总结 RxJava2 中常用的变操作符

示意图

  • 通下的岁月,我拿不止生产 AndroidRxjava 2.0
    的同样多样文章,包括原理、操作符、应用场景、背压等等

    ,有趣味可以连续关注Carson_Ho的安卓开发笔记!!

示意图


伸手点赞!因为你的砥砺是自家作的极致要命动力!

相关文章读

  • 操作符使用
    Android:这是如出一辙首 清晰 & 易懂的Rxjava
    入门教程
    Android RxJava:最基础的操作符详解 –
    创建操作符
    Android RxJava:图文详解
    变换操作符
    Android RxJava:组合 / 合并操作符
    详细教程
    Android RxJava:功能性操作符
    全面授课
  • 实则行使讲解
    Android RxJava
    实际用讲解:(无条件)网络要轮询
    Android RxJava
    实际应用讲解:(有原则)网络要轮询
    Android RxJava
    实际采用讲解:网络要嵌套回调
    Android RxJava
    实际行使讲解:合并数据源
    Android RxJava 实际使用讲解:从磁盘 / 内存缓存着
    获取缓存数据
    Android RxJava
    实际利用讲解:联合判断
    Android RxJava:细说 线程控制(切换 / 调度
    )(含Retrofit实例讲解)
    Android RxJava
    实际使用讲解:网络要出错重连(结合Retrofit)

迎关注Carson_Ho的简书!

无定期分享有关安卓开发的干货,追求短、平、快,但倒是休亏深度