Rxjava2(二）变换操作符

变换操作符

转载：https://www.jianshu.com/p/904c14d253ba

map

// 将被观察者发送的事件转换为任意的类型事件
private void map() {
    Observable.just(1,2,3)
            .map(new Function<Integer, String>() {
                @Override
                public String apply(Integer integer) throws Exception {
                    return "我是转换后的数据"+integer;
                }
            }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
                LogUtils.syso("======accept====="+s);
        }
    });
}

示意图

应用场景
数据类型转换

flatmap

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

private void flatMap() {
    final Integer[] items={1,2,3,4};
    Observable.just(items)
            .flatMap(new Function<Integer[], ObservableSource<? extends String >>() {
                @Override
                public ObservableSource<?  extends String> apply(Integer[] integers) throws Exception {
                    List<String> mList=new ArrayList<>();
                    for (int j = 0; j < integers.length; j++) {
                        mList.add("我是事件"+integers[j]);
                    }
                    return Observable.fromIterable(mList);
                }
            }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            LogUtils.syso("======accept===="+s);
        }
    });
}

应用场景

无序的将被观察者发送的整个事件序列进行变换

concatMap

/**
 * 作用：类似FlatMap（）操作符

 与FlatMap（）的 区别在于：拆分 & 重新合并生成的事件序列 的顺序 = 被观察者旧序列生产的顺序
 *
 * */
private void concatMap() {
    final Integer[] items={1,2,3,4};
    Observable.just(items)
            .concatMap(new Function<Integer[], ObservableSource<? extends String >>() {
                @Override
                public ObservableSource<?  extends String> apply(Integer[] integers) throws Exception {
                    List<String> mList=new ArrayList<>();
                    for (int j = 0; j < integers.length; j++) {
                        mList.add("我是事件"+integers[j]);
                    }
                    return Observable.fromIterable(mList);
                }
            }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            LogUtils.syso("======accept===="+s);
        }
    });
}

buffer

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

private void buffer() {
    final Integer[] items={1,2,3,4};
    Observable.fromArray(items)
       .buffer(3,1)
          .concatMap(new Function<List<Integer>, ObservableSource<? extends Integer>>() {
              @Override
              public ObservableSource<? extends Integer> apply(List<Integer> integers) throws Exception {
                  return Observable.fromIterable(integers);
              }
          }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            LogUtils.syso("=======accept==="+integer);
        }
    });
}

参考：

小结：

Rxjava2(二）变换操作符

猜你喜欢