Rxjava转换操作符

参考：https://www.jianshu.com/p/904c14d253ba

作用 ： 将事件类型转换成我们所要的结果类型。

1. Map
2. FlatMap
3. GroupBy
4. Buffer
5. Scan
6. Window

以下代码在单元测试的ExampleUnitTest中运行。

1 Map

对 被观察者发送的每1个事件都通过 指定的函数 处理，从而变换成另外一种事件。即， 将被观察者发送的事件转换为任意的类型事件。

    @Test
    public void testMap() {
        Observable.just(1, 2, 3).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return integer.toString();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }
            @Override
            public void onNext(String s) {
                System.out.println("处理  " + s);
            }
            @Override
            public void onError(Throwable e) {

            }
            @Override
            public void onComplete() {
            }
        });
    }

输出结果：

处理 1
处理 2
处理 3

从上面可以看出，map() 将参数中的 Integer 类型对象转换成一个 String类型 对象后返回。同时，事件的参数类型也由 Integer 类型变成了 String 类型。

2 FlatMap

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

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

原理：

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

在处理网络请求的时候，在未登陆状态想获取用户信息，就必须先请求登录接口，登陆成功后才能去请求用户信息接口。即，在上一个请求完成之后，才能进行下一个请求。

  	@Test
    public void testFlatMap(){
        
        Observable.just("login","getUserInfo").flatMap(new Function<String, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(String s) throws Exception {
                return createResponce(s);
            }
        }).subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Object o) {
                System.out.println(o.toString());
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
        
    }
  private ObservableSource<?> createResponce(final String s) {
        return Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("我是事件 " + s);
            }
        });

    }

输出结果：

我是事件 login
我是事件 getUserInfo

3 GroupBy

根据条件进行分类

 @Test
    public void testGroupBy() {

        Observable.just(1,2,3,4,5,6).groupBy(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return integer>2?"A组":"B组";
            }
        }).subscribe(new Consumer<GroupedObservable<String, Integer>>() {
            @Override
            public void accept(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) throws Exception {

                stringIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        String key = stringIntegerGroupedObservable.getKey();
                        System.out.println("key " + key);
                    }
                });

            }
        });
    }

输出结果：

key B组
key B组
key A组
key A组
key A组
key A组

4 Buffer

buffer操作符是把多个元素打包成一个元素一次过发送数据.

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

适用场景 ：10000条数据插入到数据库中时 每一条数据产生都需要时间。如果产生一条 插入一条比较浪给时间，全部一次性插入用户等的太久
。采取buffer的形式 将10000条 分成 一小段执行。

Buffer（）每次是获取多少个事件放到缓存区中的呢？

    @Test
    public void testBuffer() throws Exception {
        Observable.just(1, 2, 3, 4, 5, 6,7,8).buffer(3).subscribe(new Observer<List<Integer>>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(List<Integer> integers) {
                System.out.println("" + integers);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

输出结果：

[1, 2, 3]
[4, 5, 6]
[7, 8]

buffer中还有一个skip的参数，设置如下：

    @Test
    public void testBuffer() throws Exception {
        Observable.just(1, 2, 3, 4, 5, 6,7,8).buffer(3,1).subscribe(new Observer<List<Integer>>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(List<Integer> integers) {
                System.out.println("" + integers);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                System.out.println("对Complete事件作出响应");
            }
        });
    }

输出结果：

[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]
[7, 8]
[8]
对Complete事件作出响应

如果skip设置为2，则输出结果：

[1, 2, 3]
[3, 4, 5]
[5, 6, 7]
[7, 8]
对Complete事件作出响应

5 Scan

多个文件合并成一个大文件，一段一段小文件向大文件积累。上个结果作为下一个参数，所有参数合并得到最终的结果。

    @Test
    public void testScan(){
        Observable.range(1,6).scan(new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) throws Exception {
                return integer + integer2;
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
            }
            @Override
            public void onNext(Integer integer) {
                System.out.println("" + integer);
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
            }
        });
    }

输出结果：

1
3
6
10
15
21

---