什么'；Java 8中map（）和flatMap（）方法的区别是什么？

在Java8中，和方法之间有什么区别？

Stream.flatMap

，可以从它的名字猜出来，是

map

和

flat

操作的组合。这意味着您首先将函数应用于元素，然后将其展平

Stream.map

仅对流应用函数，而不展平流

---

为了理解流是什么组成的，考虑一个结构，比如[>[1]，[1,2,3]，[4]，[5]，[6]，[7，8]，[9]）/[Cord>]。扁平化意味着将其转换为“一级”结构：

[1,2,3,4,5,6,7,8,9]

传递给

流的函数。map

必须返回一个对象。这意味着输入流中的每个对象在输出流中只产生一个对象

[1, 2, 3, 4, 5] -> apply e -> e * e -> [ 1*1, 2*2, 3*3, 4*4, 5*5 ] -> [1, 4, 9, 16, 25 ]

---

传递给

stream.flatMap

的函数为每个对象返回一个流。这意味着函数可以为每个输入对象返回任意数量的对象（包括无）。然后将结果流连接到一个输出流。

可以将

map

和

flatMap

应用于

流

，它们都返回

流

。不同之处在于

map

操作为每个输入值生成一个输出值，而

flatMap

操作为每个输入值生成任意数量（零或更多）的值

[1, 2, 3, 4, 5] -> apply e -> e * e -> [ 1*1, 2*2, 3*3, 4*4, 5*5 ] -> [1, 4, 9, 16, 25 ]

这反映在每个操作的参数中

map

操作采用一个

函数

，该函数为输入流中的每个值调用，并生成一个结果值，然后发送到输出流

[1, 2, 3, 4, 5] -> apply e -> e * e -> [ 1*1, 2*2, 3*3, 4*4, 5*5 ] -> [1, 4, 9, 16, 25 ]

flatMap

操作采用的函数在概念上希望使用一个值并生成任意数量的值。然而，在Java中，方法返回任意数量的值是很麻烦的，因为方法只能返回零或一个值。可以想象一个API，其中

flatMap

的映射器函数获取一个值并返回一个数组或值的

列表，然后将其发送到输出。鉴于这是streams库，表示任意数量的返回值的一种特别合适的方法是映射器函数本身返回流！映射器返回的流中的值从流中排出并传递到输出流。每次调用mapper函数返回的值的“束”在输出流中根本没有区别，因此输出被称为“平坦”

典型的用法是
flatMap
的映射器函数返回
Stream.empty（）
如果它想发送零值，或者类似
Stream.of（a，b，c）
如果它想返回多个值。当然，任何流都可以返回。
我想举两个例子来获得更实际的观点：

使用
map
的第一个示例：

List<Integer> result = Stream.of(Arrays.asList(1), Arrays.asList(2, 3))
  .flatMap(i -> i.stream())
  .collect(Collectors.toList());

@测试
public void convertStringToUpperCaseStreams（）{
List collected=Stream.of（“a”、“b”、“hello”）//字符串流
.map（String:：toUpperCase）//返回一个流，该流包含将给定函数应用于该流元素的结果。
.collect（Collectors.toList（））；
资产质量（asList（“A”、“B”、“你好”），已收集）；
}

在第一个例子中没有什么特别的，一个
函数
用于返回大写的
字符串

使用
flatMap
的第二个示例：

List<Integer> result = Stream.of(Arrays.asList(1), Arrays.asList(2, 3))
  .flatMap(i -> i.stream())
  .collect(Collectors.toList());

@测试
public void testflatMap（）引发异常{
List together=Stream.of（asList（1,2），asList（3,4））//列表流
.flatMap（列表：：流）
.map（整数->整数+1）
.collect（Collectors.toList（））；
资产质量（asList（2,3,4,5）加在一起）；
}

在第二个示例中，传递了一个列表流它不是整数流

如果必须使用转换函数（通过映射），则首先必须将流展平为其他内容（整数流）。

如果删除了
flatMap
，则返回以下错误：参数类型列表的运算符+未定义，int.

不可能在整数的
列表上应用+1
 请仔细阅读这篇文章以获得清晰的想法，

地图与平面地图：

String[] arrayOfWords = {"STACK", "OOOVVVER"};
Stream<String> streamOfWords = Arrays.stream(arrayOfWords);
streamOfWords.map(s->s.split("")) //Converting word in to array of letters
    .flatMap(Arrays::stream).distinct() //flattens each generated stream in to a single stream
    .collect(Collectors.toList());

要从列表中返回每个单词的长度，我们将执行以下操作..

简短版本如下
当我们收集以下两个列表时

不带平面图=>[1,2]，[1,1]=>[[1,2]，[1,1]]这里两个列表放在一个列表中，因此输出将是包含列表的列表

使用平面映射=>[1,2]，[1,1]=>[1,2,1,1]这里两个列表被展平，只有值被放置在列表中，因此输出将是仅包含元素的列表

基本上它将所有对象合并为一个

##详细版本如下：-

例如：-
考虑一个列表[“STACK”，“OOOVVVER”]，我们试图返回一个类似[“STACKOVER”]的列表（只返回该列表中唯一的字母）
最初，我们将执行如下操作，从[“STACK”，“OOOVVVER”]返回一个列表[“STACKOVER”]

public class WordMap {
  public static void main(String[] args) {
    List<String> lst = Arrays.asList("STACK","OOOVER");
    lst.stream().map(w->w.split("")).distinct().collect(Collectors.toList());
  }
}

公共类WordMap{
公共静态void main（字符串[]args）{
List lst=Arrays.asList（“STACK”、“OOOVER”）；
lst.stream（）.map（w->w.split（“”）.distinct（）.collect（Collectors.toList（））；
}
}

这里的问题是，传递给map方法的Lambda为每个单词返回一个字符串数组，因此map方法返回的流
[economics, biology, geography, science, history, math]

String version = computer.map(Computer::getSoundcard)
                  .map(Soundcard::getUSB)
                  .map(USB::getVersion)
                  .orElse("UNKNOWN");

String version = computer.flatMap(Computer::getSoundcard)
                   .flatMap(Soundcard::getUSB)
                   .map(USB::getVersion)
                   .orElse("UNKNOWN");

List<List<Integer>> result = Stream.of(Arrays.asList(1), Arrays.asList(2, 3))
  .collect(Collectors.toList());

List<Integer> result = Stream.of(Arrays.asList(1), Arrays.asList(2, 3))
  .flatMap(i -> i.stream())
  .collect(Collectors.toList());

Optional<Optional<String>> result = Optional.of(42)
      .map(id -> findById(id));

Optional<String> result = Optional.of(42)
      .flatMap(id -> findById(id));

private Optional<String> findById(Integer id)

[a,b,c] f(x) => [f(a),f(b),f(c)]

[[a,b],[c,d,e]] f(x) =>[f(a),f(b),f(c),f(d),f(e)]

Stream
  .of(1,2,3,4,5)
  .map(myInt -> "preFix_"+myInt)
  .forEach(System.out::println);

dev_team = {dev_1,dev_2,dev_3}

dev_1 = {lang_a,lang_b,lang_c},
dev_2 = {lang_d},
dev_2 = {lang_e,lang_f}

dev_team.map(dev -> dev.getLanguages())

{ 
  {lang_a,lang_b,lang_c},
  {lang_d},
  {lang_e,lang_f}
}

dev_team
   .stream()    /* {dev_1,dev_2,dev_3} */
   .map(dev -> dev.getLanguages()) /* {{lang_a,...,lang_c},{lang_d}{lang_e,lang_f}}} */
   .flatMap(languages ->  languages.stream()) /* {lang_a,...,lang_d, lang_e, lang_f} */
   .doWhateverWithYourNewStreamHere();

dev_team
       .stream()    /* {dev_1,dev_2,dev_3} */
       .flatMap(dev -> dev.getLanguages().stream()) /* {lang_a,...,lang_d, lang_e, lang_f} */
       .doWhateverWithYourNewStreamHere();

List<Foo> myFoos = new ArrayList<Foo>();
    for(Foo foo: myFoos){
        for(Bar bar:  foo.getMyBars()){
            System.out.println(bar.getMyName());
        }
    }

myFoos
    .stream()
    .flatMap(foo -> foo.getMyBars().stream())
    .forEach(bar -> System.out.println(bar.getMyName()));

-------- Without flatMap() -------------------------------
     collect() returns: [[Laptop, Phone], [Mouse, Keyboard]]

-------- With flatMap() ----------------------------------
     collect() returns: [Laptop, Phone, Mouse, Keyboard]

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

public class Parcel {
  String name;
  List<String> items;

  public Parcel(String name, String... items) {
    this.name = name;
    this.items = Arrays.asList(items);
  }

  public List<String> getItems() {
    return items;
  }

  public static void main(String[] args) {
    Parcel amazon = new Parcel("amazon", "Laptop", "Phone");
    Parcel ebay = new Parcel("ebay", "Mouse", "Keyboard");
    List<Parcel> parcels = Arrays.asList(amazon, ebay);

    System.out.println("-------- Without flatMap() ---------------------------");
    List<List<String>> mapReturn = parcels.stream()
      .map(Parcel::getItems)
      .collect(Collectors.toList());
    System.out.println("\t collect() returns: " + mapReturn);

    System.out.println("\n-------- With flatMap() ------------------------------");
    List<String> flatMapReturn = parcels.stream()
      .map(Parcel::getItems)
      .flatMap(Collection::stream)
      .collect(Collectors.toList());
    System.out.println("\t collect() returns: " + flatMapReturn);
  }
}

Stream.of("dog", "cat")              // stream of 2 Strings
    .map(s -> s.length())            // stream of 2 Integers: [3, 3]

Stream.of("dog", "cat")             // stream of 2 Strings
    .flatMapToInt(s -> s.chars())   // stream of 6 ints:      [d, o, g, c, a, t]