java8中stream的map和flatmap的理解

Posted lijingran

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java8中stream的map和flatmap的理解相关的知识,希望对你有一定的参考价值。

转自https://blog.csdn.net/wynjauu/article/details/78741093

假如我们有这样一个需求给定单词列表["Hello","World"],你想要返回列表["H","e","l", "o","W","r","d"],
对于这样的需求,我们可能想到的第一个版本可能是这样子的:

words.stream()
.map(word -> word.split(""))
.distinct()
.collect(toList());

这个方法的问题在于,传递给map方法的Lambda为每个单词返回了一个String[](String
列表)。因此, map 返回的流实际上是Stream<String[]> 类型的。你真正想要的是用
Stream<String>来表示一个字符流。因此,这是行不通的。

以下是我对这个问题的解法和分步写法,希望能对你有帮助:

对flatMap的说明:这个在这里的主要作用是对流进行扁平化
String ss = "Hello";
 2 
 3         String[] aa = ss.split("");
 4 
 5         String[] bb = {"H", "e", "l", "l", "o"};
 6 
 7 
 8         String[] strings = {"Hello", "World"};
 9 
10         //Arrays.stream接收一个数组返回一个流
11         List<Stream<String>> streamList = Arrays.asList(strings).stream().
12                 map(str -> str.split("")).
13                 map(str -> Arrays.stream(str)).
14                 collect(Collectors.toList());
15 
16         //分步写(map)
17 
18         Stream<String[]> stream = Arrays.asList(strings).stream().
19                 map(str -> str.split(""));
20 
21         Stream<Stream<String>> streamStream = stream.map(strings1 -> Arrays.stream(strings1));
22         List<Stream<String>> streamList1 = streamStream.collect(Collectors.toList());
23 
24 
25         List<String> stringList = Arrays.asList(strings).stream().
26                 map(str -> str.split("")).
27                 flatMap(str -> Arrays.stream(str))
28                 .collect(Collectors.toList());
29 
30 
31         //分步写(流只能消费一次)(flatMap)
32         Stream<String[]> stream1 = Arrays.asList(strings).stream().
33                 map(str -> str.split(""));
34 
35         Stream<String> stringStream = stream1.flatMap(strings1 -> Arrays.stream(strings1));
36 
37         List<String> stringList1 = stringStream.collect(Collectors.toList());

另一篇转自:jdk8 Stream map和flatMap区别

  • 1.map

  • 将一种类型的值转换为另外一种类型的值。
  • 代码:将List 转换成List
 List<String> collected = Stream.of("a", "b").collect(Collectors.toList());
 
  List<Integer> figure = collected.stream().map(s -> {
            Integer i;
            switch (s) {
                case "a":
                    i = 1;
                    break;
                case "b":
                    i = 2;
                    break;
                default:
                    i = -1;
                    break;
            }
            return i;
        }).collect(Collectors.toList());
  • 2.flatMap(类似C# AddRange)

  • 将多个Stream连接成一个Stream,这时候不是用新值取代Stream的值,与map有所区别,这是重新生成一个Stream对象取而代之。
   List<Integer> a=new ArrayList<>();
        a.add(1);
        a.add(2);
        List<Integer> b=new ArrayList<>();
        b.add(3);
        b.add(4);
        List<Integer> figures=Stream.of(a,b).flatMap(u->u.stream()).collect(Collectors.toList());
        figures.forEach(f->System.out.println(f));
    • 或者看下面这个例子

    • flatMap方法
      [java] view plain copy
      1. List<String> words = new ArrayList<String>();
      2. words.add("your");
      3. words.add("name");


      4. public static Stream<Character> characterStream(String s){  
      5.     List<Character> result = new ArrayList<>();  
      6.     for (char c : s.toCharArray()) 
      7.         result.add(c);
      8.     return result.stream();  
      9. }
      10.   
      11. Stream<Stream<Character>> result = words.map(w -> characterStream(w));  
      12.   
      13. Stream<Character> letters = words.flatMap(w -> characterStream(w));  
      如果使用的是map方法,返回的是[ ...[‘y‘, ‘o‘, ‘u‘, ‘r‘], [‘n‘, ‘a‘, ‘m‘, ‘e‘]]

       

      如果使用的是flatMap方法,返回的是[‘y‘, ‘o‘, ‘u‘, ‘r‘, ‘n‘, ‘a‘, ‘m‘, ‘e‘]

      这是map和flatMap的区别

    •  

          @Test  
              public void testMapAndFlatMap() {  
                  List<String> words = new ArrayList<String>();  
                  words.add("hello");  
                  words.add("word");  
            
                  //将words数组中的元素再按照字符拆分,然后字符去重,最终达到["h", "e", "l", "o", "w", "r", "d"]  
                  //如果使用map,是达不到直接转化成List<String>的结果  
                  List<String> stringList = words.stream()  
                          .flatMap(word -> Arrays.stream(word.split("")))  
                          .distinct()  
                          .collect(Collectors.toList());  
                  stringList.forEach(e -> System.out.println(e));  
              }

       







以上是关于java8中stream的map和flatmap的理解的主要内容,如果未能解决你的问题,请参考以下文章

Java8中map()和flatMap()的区别

Java8Stream的flatmap方法使用

java8 stream limit distinct map flatMap

Java 8 中的 map() 和 flatMap() 方法有啥区别?

java8中的map与flatmap

Java8 Stream流