Rxjava map和flatMap区别

最新推荐文章于 2025-06-21 10:25:26 发布

new_abc

最新推荐文章于 2025-06-21 10:25:26 发布

阅读量1.2w

点赞数 4

CC 4.0 BY-SA版权

分类专栏： RxJava

本文链接：https://blog.youkuaiyun.com/new_abc/article/details/84318464

RxJava 专栏收录该内容

50 篇文章

订阅专栏

本文深入探讨了RxJava中Map和FlatMap操作符的区别，包括它们的返回值类型、变换规则及应用场景。通过实例演示了如何使用这两个操作符进行一对一、一对多及多对多的数据变换。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

map和flatMap都是依赖传入的Function对数据进行变换

但是

1、返回值上面：

map变换后可以返回任意值，而flatMap则只能返回ObservableSource类型

2、变换后的输出：

map只能进行一对一的变换，而flatMap则可以进行一对一，一对多，多对多的变换，具体的变换规则根据我们设置的变换函数mapper来定

demo

List<String> list = new ArrayList<>();
        list.add("b");
        list.add("a");
        list.add("c");
        System.out.println("1对1:[b, a, c]-->[b, a, c]");
        //1对1
        Observable.just(list)
                .flatMap(
                        new Function<List<String>, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(List<String> s) throws Exception {
//                                System.out.println("map--1----" + s);
                                return Observable.fromArray(s);
                            }
                        })
                .subscribe(s -> {
                    System.out.println(s);
                });
        System.out.println("1对多:[b, a, c]-->b, a, c");
        //1对多
        Observable.just(list)
                .flatMap(
                        new Function<List<String>, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(List<String> s) throws Exception {
//                                System.out.println("map--1----" + s);
                                return Observable.fromIterable(s);
                            }
                        })
                .subscribe(s -> {
                    System.out.println(s);
                });

        //1对多
        System.out.println("多对多:a, b, c-->[a, c]");
        Observable.just("a", "b", "c")
                .flatMap(
                        new Function<String, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(String s) throws Exception {
//                                System.out.println("map--1----" + s);
                                if (s.equalsIgnoreCase("b")) return Observable.empty();
                                return Observable.just(s);
                            }
                        })
                .subscribe(s -> {
                    System.out.println(s);
                });

        //1对多
        System.out.println("多对多:a, b, c-->a,b,c,d");
        Observable.just("a", "b", "c")
                .flatMap(
                        new Function<String, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(String s) throws Exception {
//                                System.out.println("map--1----" + s);
                                if (s.equalsIgnoreCase("c")) return Observable.just("c", "d");
                                return Observable.just(s);
                            }
                        })
                .subscribe(s -> {
                    System.out.println(s);
                });
        System.out.println("map 一对一:[b, a, c]-->[b, a, c]");
        Observable.just(list)
                .map(new Function<List<String>, List<String>>() {
                    @Override
                    public List<String> apply(List<String> strings) throws Exception {
                        return strings;
                    }
                })
                .subscribe(s -> {
                    System.out.println(s);
                });

输出：

1对1:[b, a, c]-->[b, a, c]
[b, a, c]
1对多:[b, a, c]-->b, a, c
b
a
c
多对多:a, b, c-->[a, c]
a
c
多对多:a, b, c-->a,b,c,d
a
b
c
d
map 一对一:[b, a, c]-->[b, a, c]
[b, a, c]