RxJava2.0之旅（三）---变换操作符

1 变换操作符作用

• 对事件序列中的事件 / 整个事件序列 进行加工处理（即变换），使得其转变成不同的事件 / 整个事件序列

类型	作用	备注
Map()	发送的每1个事件都通过 指定的函数处理，从而变换成另外一种事件
FlatMap()	将被观察者发送的事件序列进行 拆分 & 单独转换，再（并发）合并成一个新的事件序列，最后再进行发送	新合并生成的事件序列顺序是无序的，即 与旧序列发送事件的顺序无关
ConcatMap()	将被观察者发送的事件序列进行 拆分 & 单独转换，再合并成一个新的事件序列，最后再进行发送	拆分 & 重新合并生成的事件序列 的顺序 = 被观察者旧序列生产的顺序
Buffer()	定期从 被观察者（Obervable）需要发送的事件中 获取一定数量的事件 & 放到缓存区中，最终发送	* 缓存区大小 = 每次从被观察者中获取的事件数量 * 步长 = 每隔步长个事件，取一次

944365-45e3d263d098c4ee.png

2 类型

944365-71eb569b296c1f18.png

2.1 Map()

• 作用
• 对 被观察者发送的每1个事件都通过 指定的函数 处理，从而变换成另外一种事件

944365-a9c0b5eb2cc573d6.png

• 应用场景
  如：数据类型转换

private void map() {
    // 采用RxJava基于事件流的链式操作
    // 1. 被观察者发送事件 = 参数为整型 = 1、2、3
    Observable.just(1, 2, 3)
            // 2. 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：整型变换成字符串类型
            .map(new Function() {
                @Override
                public String apply(Integer integer) throws Exception {
                    return "字符串类型" + String.valueOf(integer);
                }
            })
            .subscribe(new Consumer() {
                // 3. 观察者接收事件时，是接收到变换后的事件 = 字符串类型
                @Override
                public void accept(String s) throws Exception {
                    Log.d(TAG, s);
                }
            });
}

TIM截图20180601153339.png

• map() 将参数中的 Integer 类型对象转换成一个 String类型 对象后返回

2.2FlatMap()

• 作用
• 将被观察者发送的事件序列进行 拆分 & 单独转换，再合并成一个新的事件序列，最后再进行发送

• 原理
• 1.为事件序列中每个事件都创建一个 Observable 对象；
• 2.将对每个 原始事件 转换后的 新事件 都放入到对应 Observable对象；
• 3.将新建的每个Observable 都(并发)合并到一个 新建的、总的Observable 对象；
• 4.新建的、总的Observable 对象 将 新合并的事件序列 发送给观察者（Observer）

944365-a6f852c071db2f15.png

• 应用场景
  如：无序的将被观察者发送的整个事件序列进行变换

private void flatMap() {
    // 采用RxJava基于事件流的链式操作
    Observable.just(1, 2, 3)
            // 采用flatMap（）变换操作符
            .flatMap(new Function>() {
                @Override
                public ObservableSource apply(Integer integer) throws Exception {
                    ArrayList list = new ArrayList<>();
                    for (int i = 0; i < 2; i++) {
                        list.add("我是事件:" + integer + "--下的子事件:" + i);
                        // 通过flatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送2个String事件
                        // 最终合并，再发送给被观察者
                    }
                    return Observable.fromIterable(list);
                }
            })
            .subscribe(new Consumer() {
                @Override
                public void accept(String s) throws Exception {
                    Log.d(TAG, s);
                }
            });
}

TIM截图20180601155158.png

• 注：新合并生成的事件序列顺序是无序的，即 与旧序列发送事件的顺序无关

2.3 ConcatMap()

• 作用
• 类似FlatMap（）操作符
• 与FlatMap（）的 区别在于：拆分 & 重新合并生成的事件序列 的顺序 = 被观察者旧序列生产的顺序

944365-f4340f283e5a954d.png

• 应用场景
  如：有序的将被观察者发送的整个事件序列进行变换

private void concatMap() {
    // 采用RxJava基于事件流的链式操作
    Observable.just(1, 2, 3)
            // 采用concatMap（）变换操作符
            .concatMap(new Function>() {
                @Override
                public ObservableSource apply(Integer integer) throws Exception {
                    ArrayList list = new ArrayList<>();
                    for (int i = 0; i < 2; i++) {
                        list.add("我是事件:" + integer + "--下的子事件:" + i);
                        // 通过flatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送2个String事件
                        // 最终合并，再发送给被观察者
                    }
                    return Observable.fromIterable(list);
                }
            })
            .subscribe(new Consumer() {
                @Override
                public void accept(String s) throws Exception {
                    Log.d(TAG, s);
                }
            });
}

TIM截图20180601161402.png

• 注：新合并生成的事件序列顺序是有序的，即 严格按照旧序列发送事件的顺序

2.4 Buffer()

• 作用
• 定期从 被观察者（Obervable）需要发送的事件中 获取一定数量的事件 & 放到缓存区中，最终发送

944365-5278a339e4337494.png

• 应用场景
  缓存被观察者发送的事件

private void buffer() {
    Observable.just(1, 2, 3, 4, 5)
            .buffer(3, 2)
            // 设置缓存区大小 & 步长
            // 缓存区大小 = 每次从被观察者中获取的事件数量
            // 步长 = 每隔步长个事件，去一次
            .subscribe(new Observer>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

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

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

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

}

TIM截图20180601162722.png

参考

https://www.jianshu.com/p/904c14d253ba