如果您熟悉C#，也可以使用C#进行很好的类比。基本上，C#Select类似于javamap和C#SelectMany javaflatMap。同样适用于集合的静态编程语言。

我有一种感觉，这里的大多数答案都将简单的问题复杂化了。如果你已经理解了map是如何工作的，那应该很容易掌握。

在某些情况下，当使用map()时，我们可能会得到不需要的嵌套结构，flatMap()方法旨在通过避免包装来克服这一点。

示例：

1

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

我们可以通过使用flatMap来避免嵌套列表：

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

2

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)

对于Map，我们有一个元素列表和一个（函数，动作）f：

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

对于平面map，我们有一个元素列表，我们有一个（函数，动作）f，我们希望结果被扁平化：

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

这对初学者来说是非常混乱的。基本区别是map为列表中的每个条目发出一个项目，而flatMap基本上是map+flatten操作。更清楚地说，当你需要多个值时，使用flatMap，例如，当你期望一个循环返回数组时，flatMap在这种情况下真的很有帮助。

我写了一篇关于这个的博客，你可以看看这里。

map（）和platMap（）

1. map()

只需要一个函数一个lambda参数，其中T是元素，R是使用T构建的返回元素。最后，我们将有一个带有类型R的对象的Stream。一个简单的例子可以是：

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

它只是获取类型Integer的元素1到5，使用每个元素从类型String构建一个值为"prefix_"+integer_value的新元素并将其打印出来。

2. flatMap()

这是有用的要知道，flatMap（）需要一个函数F<T, R>在哪里

• T是来自可以从哪个Stream构建/使用哪个Stream的类型。它可以是List（T.stream（））、数组（Arrays.stream（一些数组））等…任何可以与Stream一起/或形成的东西。在下面的示例中，每个开发人员都有许多语言，因此开发语言是一个List，将使用一个lambda参数。

• R是将使用T构建的结果Stream。知道我们有很多T的实例，我们自然会有很多来自R的Streams。来自R型的所有这些Streams将现在合并成一个来自R型的单个“平面”Stream。

示例

Bachiri Taoufiq的例子[见这里的答案]1简单易懂。为了清楚起见，假设我们有一个开发团队：

dev_team = {dev_1,dev_2,dev_3}

，每个开发人员都知道多种语言：

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

在dev_team上应用Stream.map（）以获取每个开发人员的语言：

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

会给你这个结构：

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

这基本上是一个List<List<Languages>> /Object[Languages[]]。不太漂亮，也不像Java8！！

使用Stream.flatMap()，您可以“扁平化”事物，因为它采用上述结构
并将其转换为{lang_a, lang_b, lang_c, lang_d, lang_e, lang_f}，基本上可以用作List<Languages>/Language[]/etc…

所以最后，你的代码会像这样更有意义：

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();

什么时候使用map（）和ping Map（）：

• 当流中T类型的每个元素都应该映射/转换为R类型的单一元素时，使用map()。结果是类型（1个起始元素->1个结束元素）的映射，并返回R类型的新元素流。

• 当流中的每个T类型元素都应该映射/转换为R类型元素的收藏时，使用flatMap()。结果是类型（1个开始元素->n个结束元素）的映射。然后，这些集合合并（或扁平化）到R类型元素的新流。这对于表示嵌套循环很有用。

Java8：

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

Java8

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

流操作flatMap和map接受一个函数作为输入。

flatMap期望函数为流的每个元素返回一个新流，并返回一个流，该流组合了函数为每个元素返回的流的所有元素。换句话说，对于flatMap，对于源中的每个元素，函数将创建多个元素。http://www.zoftino.com/java-stream-examples#flatmap-operation

map期望函数返回一个转换后的值并返回一个包含转换后元素的新流。换句话说，对于map，对于源中的每个元素，函数将创建一个转换后的元素。http://www.zoftino.com/java-stream-examples#map-operation

一行回答：#0有助于将#1展平为#2.以同样的方式，它也会将Optional<Optional<T>>压平为Optional<T>。

如你所见，只有map()：

• 中间类型是Stream<List<Item>>
• 返回类型为List<List<Item>>

与flatMap()：

• 中间类型是Stream<Item>
• 返回类型为List<Item>

这是下面使用的代码中的测试结果：

-------- 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);}}

我不太确定我应该回答这个问题，但每次我面对不理解这个问题的人时，我都会用同样的例子。

假设你有一个苹果。例如，map正在将该苹果转换为apple-juice或一对一映射。

拿同一个苹果，只从里面得到种子，这就是flatMap所做的，或者一对多，一个苹果作为输入，许多种子作为输出。

flatMap()还利用了流的部分惰性评估。它将读取第一个流，只有在需要时才会转到下一个流。这种行为在这里详细解释：就一定会是懒的吗？

简单的回答。

map操作可以产生Stream的Stream.EXStream<Stream<Integer>>

flatMap操作只会产生Stream的东西。EXStream<Integer>

如果你认为map()是一个迭代（一个级别for循环），flatmap()是一个两级迭代（就像嵌套的for循环）。（输入每个迭代元素foo，然后执行foo.getBarList()并再次迭代barList）

map()：取一个流，对每个元素做一些事情，收集每个过程的单个结果，输出另一个流。“做某事函数”的定义是隐式的。如果任何元素的处理结果为null，则使用null来组成最终的流。因此，结果流中的元素数量将等于进审量流。

flatmap()：取一个元素/流的流和一个函数（显式定义），将函数应用于每个流的每个元素，并收集所有中间结果流为更大的流（“展平”）。如果任何元素的处理结果为null，则为“展平”的最后一步提供空流。结果流中的元素数量，是所有输入中所有参与元素的总和，如果输入是几个流。

. map用于#0映射

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

它将任何项目A转换为任何项目B。Javadoc

. flamMap用于#0连接

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

它--1将任何项目A转换为Stream< B>，然后--2将所有流连接成一个（平面）流。Javadoc

注1：尽管后一个示例平坦到原语流（IntStream）而不是对象流（Stream），但它仍然说明了.flatMap的想法。

注2：尽管有名称，String.chars（）方法返回整数。所以实际的集合将是：[100, 111, 103, 99, 97, 116]，其中100是'd'的代码，111是'o'等的代码。同样，出于说明目的，它被表示为[d， o， g， c， a， t]。

通过阅读所有消息，理解的简单方法是：

• 如果您有flat元素列表，请使用map：[0,1,2,3,4,5]
• 如果您有一个元素列表：[[1,3,5]，[2,4,6]]，请使用flatMap。这意味着，您的列表需要是扁平化才能将地图操作应用于每个元素

map（）获取一个Stream并将其转换为另一个Stream。它在Stream的每个元素上应用一个函数，并将返回值存储到新的Stream中。它不会展平流。但是flattMap（）是map和平面操作的组合，即它将函数应用于元素并展平它们。2）map（）仅用于转换，但flattMap（）用于转换和展平。请阅读更多这里。https://javaint4bytes.blogspot.com/2022/11/stream-flatmap-in-java-with-examples.html