Java~stream处理中map与flatMap的比较和使用案例_java stream map flatmap

前言

使用Java8的新特性Stream流式处理，可以提高对于集合的一些操作效率，再配合lambda表达式，可以极致的简化代码，尤其还有并行流这个东东，可以去 了解一下，在一些场合还是可以提高效率的，而且编码起来也不费事。

并且流式处理的核心就是一个浅拷贝和引用管道，其内部实现了一个引用管道ReferencePipeline， 他把需要处理的数据的引用拷贝了一份，然后处理数据，最后收集结果也是将这些引用放到了另一个集合中。

今天要讲的就是stream处理中的map和flatMap这俩个的比较和使用

共同点和区别

首先看一下源代码

    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
1
2
3

共同点

• 都是依赖stream进行转换，结合lambda的入参和返回值，将一个类型依据程序逻辑转换成另一种类型。
• 最后结果返回都还是一个流，还可以对其进行继续的流式处理或者进行收集。

区别

• 方法参数不同，第一个参数是一样的，但是第二个不一样，对于map第二个参数没啥要求，但是使用flatMap时，第二个参数还得用流来接收。
• 所以flatMap多用于多对多，一对多，也就是map是将一个数据流中的一个数据节点，映射成另外一个数据节点，而flatMap是将一个数据流中的一个数据节点映射成另外一个数据流，这个另外的数据流可以是一个数据节点也可以是多个数据节点。
• flatmap既可以单一转换也可以一对多/多对多转换，flatmap要求返回Observable，因此可以再内部进行from/just的再次事件分发，一一取出单一对象（转换对象的能力不同）

使用案例

比如我们使用map将一个per对象映射成一个字符串对象

    static class Per {
        public String name;
        public int age;

        public Per(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Per{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

    public static void main(String[] args) {
        List<Per> list = new ArrayList<>();
        list.add(new Per("listen", 22));
        list.add(new Per("bike", 24));
        list.add(new Per("milk", 27));

        List<String> collect = list.stream().map(Per::toString).collect(Collectors.toList());

        System.out.println(list);
        System.out.println("---");
        System.out.println(collect);

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

一对一可以实现，那我们该需求，假设一个per人有多个孩子，我们想获取这多个孩子，使用map可以实现吗？比如下面代码。

    static class Child {
        public String name;
        public int age;

        public Child(String name, int age) {
            this.name = name;
            this.age = age;
        }
                @Override
        public String toString() {
            return "Child{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

    static class Per {
        public String name;
        public int age;
        public Child[] Children;

        public Per(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public Child[] getChildren() {
            return Children;
        }

        public void setChildren(Child[] children) {
            Children = children;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Per{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

这个时候注意这个孩子是多个，我们用的是数组存储。如果此时我们还用map，那么只能接受每个per的孩子数组，不能和我们所愿接受每个孩子。

    public static void main(String[] args) {
        List<Per> list = new ArrayList<>();
        Per per1 = new Per("Listen", 22);
        per1.setChildren(new Child[] {new Child("a", 1), new Child("b", 2)});
        Per per2 = new Per("Milk", 26);
        per2.setChildren(new Child[] {new Child("c", 1), new Child("d", 2)});
        list.add(per1);
        list.add(per2);

        List<Child[]> collect = list.stream().map(Per::getChildren).collect(Collectors.toList());
        collect.forEach(item -> System.out.println(Arrays.toString(item)));
    }
1
2
3
4
5
6
7
8
9
10
11
12

而使用flatMap就可以实现。

    public static void main(String[] args) {
        List<Per> list = new ArrayList<>();
        Per per1 = new Per("Listen", 22);
        per1.setChildren(new Child[] {new Child("a", 1), new Child("b", 2)});
        Per per2 = new Per("Milk", 26);
        per2.setChildren(new Child[] {new Child("c", 1), new Child("d", 2)});
        list.add(per1);
        list.add(per2);

        List<Child> collect = list.stream().flatMap(item -> Arrays.stream(item.getChildren())).collect(Collectors.toList());
        System.out.println(collect);

    }
1
2
3
4
5
6
7
8
9
10
11
12
13