RxJava(二)-转换操作符

niuyongzhi

已于 2022-09-18 23:35:28 修改

阅读量531

点赞数

分类专栏： Java基础文章标签： rxjava android

于 2022-09-18 23:33:57 首次发布

本文链接：https://blog.csdn.net/niuyongzhi/article/details/126925247

版权

Java基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1.map
转换操作符

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("apple");
            }
        }).map(new Function<String, Fruit>() {
            @Override
            public Fruit apply(@NonNull String name) throws Exception {
                Log.e("rxjava", "apply " + name);
                return new Fruit(name);
            }
        }).subscribe(new Observer<Fruit>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull Fruit fruit) {
                Log.e("rxjava", "onNext " + fruit.toString());
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {
                Log.e("rxjava", "onComplete");
            }
        });
执行结果：
rxjava: apply0 apple
rxjava: apply1 apple_1
rxjava: onNext Fruit{name='apple_1'}

map 返回的是一个 ObservableMap<T, R>对象，接收一个 Function<T, R> 泛型类。T是传入的类型，R是返回的类型。
所谓转换，就是通过applay函数，将传入的T类型，转换成R类型。map后面可以跟多个map，将apply产生的对象，继续向下传递。
上面的例子，就是将传入的字符串"apple" 通过map的apply转换函数，转换成Fruit对象，
传递给下游的被观察者。map可以把一串Json字符串，转换成一个list的集合对象。

2.flatMap

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                for (int i = 0; i < 3; i++) {
                    emitter.onNext(String.valueOf(i));
                }
            }
        }).flatMap(new Function<String, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(@NonNull String s) throws Exception {
                List<String> list = new ArrayList<>();
                list.add("apple" + s);
                return Observable.fromIterable(list);
            }
        }).map(new Function<String, Fruit>() {
            @Override
            public Fruit apply(@NonNull String name) throws Exception {
                 Log.e("rxjava","apply "+name);
                return new Fruit(name);
            }
        }).subscribe(new Observer<Fruit>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull Fruit fruit) {
                 Log.e("rxjava","onNext "+fruit.toString());
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
执行结果：
rxjava: apply apple0
rxjava: onNext Fruit{name='apple0'}
rxjava: apply apple1
rxjava: onNext Fruit{name='apple1'}
rxjava: apply apple2
rxjava: onNext Fruit{name='apple2'}

flatMap 返回的是 ObservableFlatMap<T, R>对象，接收的是Function<? super T, ? extends ObservableSource<? extends R>>这样一个参数。
调用apply返回给下游的就是ObservableSource这样一个被观察者，而map执行apply是返回的转换后的对象，这个是map和flatMap最大的区别。

flatMap返回的是一个被观察者，下游可以跟一个被观察者也可以跟观察者。

3.concatMap
和flatMap差不多

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                for (int i = 0; i < 3; i++) {
                    emitter.onNext(String.valueOf(i));
                }
            }
        }).concatMap(new Function<String, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(@NonNull String s) throws Exception {
                List<String> list = new ArrayList<>();
                list.add("apple" + s);
                return Observable.fromIterable(list);
            }
        }).map(new Function<String, Fruit>() {
            @Override
            public Fruit apply(@NonNull String name) throws Exception {
                Log.e("rxjava","apply "+name);
                return new Fruit(name);
            }
        }).subscribe(new Observer<Fruit>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull Fruit fruit) {
                Log.e("rxjava","onNext "+fruit.toString());
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
执行结果：
rxjava: apply apple0
rxjava: onNext Fruit{name='apple0'}
rxjava: apply apple1
rxjava: onNext Fruit{name='apple1'}
rxjava: apply apple2
rxjava: onNext Fruit{name='apple2'}

concatMap返回的是ObservableConcatMap<T, R>一个对象。接收的是Function<? super T, ? extends ObservableSource<? extends R>>类型
apply返回的就是ObservableSource类型。