美学原理Android 大切诺基xJava:图像和文字详解 变换操作符

前言

  • Rxjava,由于其依照事件流的链式调用、逻辑简洁 &
    使用简易
    的特征,深受各大 Android开发者的迎接。

Github截图

若果还不住解 RxJava,请看小说:Android:那是一篇 清晰 &
易懂的CR-Vxjava 入门教程

  • 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()

  • 作用
    对 被旁观者发送的每2个事件都通过 钦命的函数
    处理,从而变换来其余一种事件

即, 将被观看者发送的风浪转换为专断的门类事件。

  • 原理

示意图

  • 采纳场景
    数据类型转换

  • 切切实实行使
    上面以将 使用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()

  • 作用:将被观望者发送的轩然大波连串举行 拆分 &
    单独转换
    ,再统一成1个新的风浪体系,最终再拓展发送

  • 原理

  1. 为事件连串中种种事件都创建二个 Observable 对象;
  2. 将对各个 原始事件 转换后的 新事件 都放入到对应 Observable对象;
  3. 将新建的各样Observable 都合并到一个 新建的、总的Observable
    对象;
  4. 新建的、总的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
  • 上面,笔者将动用3个实在应用场景实例来教学嵌套回调(Callback hell

切切实实请看作品Android 陆风X8xJava
实际行使案例教学:网络请求嵌套回调


5. Demo地址

上述全体的Demo源代码都存放在:Carson_Ho的Github地址:RxJava2_转移操作符

喜欢的麻烦点个star


6. 总结

  • 上面,作者将用一张图总计 RxJava2 中常用的更换操作符

示意图

  • 接下去的时日,自我将不断生产 AndroidRxjava 2.0
    的一多种文章,包涵原理、操作符、应用场景、背压等等

    ,有趣味可以三番八遍关切Carson_Ho的安卓开发笔记!!

示意图


请点赞!因为你的鼓励是本人创作的最大重力!

有关文章阅读


欢迎关切Carson_Ho的简书!

不定期分享关于安卓开发的干货,追求短、平、快,但却不缺深度