RxJava2知识回顾之RxJava基本操作符

最新推荐文章于 2025-07-13 09:41:38 发布

原创最新推荐文章于 2025-07-13 09:41:38 发布 · 329 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#RxJava #RxJava操作符 #操作符 #Map #Zip

RxJava 专栏收录该内容

3 篇文章

订阅专栏

本文深入解析了RxJava中的关键操作符，包括Map、FlatMap、Zip和Concat，阐述了它们的功能、使用场景及内部机制，帮助开发者更好地理解和运用这些操作符。

Map

操作符的作用是对上游发送的每一个事件应用一个函数，使得每个事件按照函数的逻辑进行变换，通过Map就可以把上游发送的每一个事件，转换成Object或者集合.

 /**
     * map关键词主要是将发送事件通过Map转换成另一种下游所需要的目标类型
     */
    public static void MapTest(){
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.e(TAG_OBSERVABLE,"被处理之前的值:1");
                emitter.onNext(1);
                Log.e(TAG_OBSERVABLE,"被处理之前的值:2");
                emitter.onNext(2);
                Log.e(TAG_OBSERVABLE,"被处理之前的值:3");
                emitter.onNext(3);
            }
        }).map(new Function<Integer, String>() {//在下游接收到事件之前处理，返回一个新的Observable
            @Override
            public String apply(Integer integer) throws Exception {
                return "我被转换成:"+integer;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG_OBSERVAER,"接收的内容:"+s);
            }
        });
    }

结果：

map 基本作用就是将一个 Observable 通过某种函数关系，转换为另一种 Observable，上面例子中就是把我们的 Integer 数据变成了 String 类型。从Log日志显而易见。

map函数调用完毕之后，将返回一个新的Observable，它的类型为ObservableMap.

使用场景：

网络请求返回结果，可以在map中进行数据解析，转换成需要的数据格式发送给下游，进行UI更新。

FlatMap

上游每发送一个事件, flatMap都将创建一个新的水管, 然后发送转换之后的新的事件, 下游接收到的就是这些新的水管发送的数据. 这里需要注意的是, flatMap并不保证事件的顺序。

concatMap与flatMap的作用几乎一样，只是concatMap结果严格按照上游发送的顺序。

Observable<Integer> integerObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.e(TAG_OBSERVABLE, "ObservableEmitter:" + Thread.currentThread().getName());
                Log.e(TAG_OBSERVABLE, "发射器1被处理之前的值:1");
                emitter.onNext(1);
                Log.e(TAG_OBSERVABLE, "发射器1被处理之前的值:2");
                emitter.onNext(2);
                Log.e(TAG_OBSERVABLE, "发射器1被处理之前的值:3");
                emitter.onNext(3);
                emitter.onComplete();
            }
        });

        integerObservable
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.newThread())
                .flatMap(new Function<Integer, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(Integer integer) throws Exception {
                        Log.e(TAG_OBSERVABLE, "apply:" + Thread.currentThread().getName());
                        List<String> list = new ArrayList<>();
                        for (int i = 0; i < 2; i++) {
                            list.add("我的值:" + integer);
                        }
                        int delayTime = (int) (1 + Math.random() * 10);
                        return Observable.fromIterable(list).delay(delayTime, TimeUnit.MILLISECONDS);
                    }
                }).subscribeOn(Schedulers.newThread())
                .observeOn(Schedulers.newThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG_OBSERVABLE, "accept:" + Thread.currentThread().getName());
                        Log.e(TAG_OBSERVAER, "接收到的:" + s);
                    }
                });

结果：

使用场景：

可以用于类似注册成功后返回的数据再调用登录接口获取用户信息，多个接口连接转换。

Zip

zip 专用于合并事件，该合并不是连接（连接操作符后面会说），而是两两配对，也就意味着，最终配对出的 Observable 发射事件数目只和少的那个相同。

/**
     * zip关键词主要是将两个事件合并成一个事件提供给下游处理
     */
    public static void zipTest(){
        Observable<Integer> integerObservable=Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.e(TAG_OBSERVABLE,"被处理之前的值:1");
                emitter.onNext(1);
                Log.e(TAG_OBSERVABLE,"被处理之前的值:2");
                emitter.onNext(2);
                Log.e(TAG_OBSERVABLE,"被处理之前的值:3");
                emitter.onNext(3);
            }
        });
        Observable<String> stringObservable=Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("我叫:");
                emitter.onNext("我女朋友叫:");
            }
        });

        Observable.zip(integerObservable, stringObservable, new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String s) throws Exception {
                return s+integer;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG_OBSERVAER,"接收的内容:"+s);
            }
        });
    }

结果：