java8中stream的map和flatmap的理解

https://www.cnblogs.com/lijingran/p/8727507.html

假如我們有這樣一個需求給定單詞列表["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";

    String[] aa = ss.split("");

    String[] bb = {"H", "e", "l", "l", "o"};


    String[] strings = {"Hello", "World"};

    //Arrays.stream接收一個數組返回一個流
    List<Stream<String>> streamList = Arrays.asList(strings).stream().
            map(str -> str.split("")).
            map(str -> Arrays.stream(str)).
            collect(Collectors.toList());

    //分步寫(map)

    Stream<String[]> stream = Arrays.asList(strings).stream().
            map(str -> str.split(""));

    Stream<Stream<String>> streamStream = stream.map(strings1 -> Arrays.stream(strings1));
    List<Stream<String>> streamList1 = streamStream.collect(Collectors.toList());


    List<String> stringList = Arrays.asList(strings).stream().
            map(str -> str.split("")).
            flatMap(str -> Arrays.stream(str))
            .collect(Collectors.toList());
 

    //分步寫(流只能消費一次)(flatMap)
    Stream<String[]> stream1 = Arrays.asList(strings).stream().
            map(str -> str.split(""));

    Stream<String> stringStream = stream1.flatMap(strings1 -> Arrays.stream(strings1));

    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方法

    List<String> words = new ArrayList<String>();
    words.add("your");
    words.add("name");
    
    
    public static Stream<Character> characterStream(String s){  
        List<Character> result = new ArrayList<>();  
        for (char c : s.toCharArray()) 
            result.add(c);
        return result.stream();  
    }
      
    Stream<Stream<Character>> result = words.map(w -> characterStream(w));  
      
    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));  
            }