别告诉我Java8都出来这么久了，你还搞不懂Stream的map和flatmap的区别？

桃扇骨 2022-10-16 00:54 16阅读 0赞

### 文章目录 ###

*   *  别告诉我Java8都出来这么久了，你还搞不懂Stream的map和flatmap的区别？
     *   *  Java8 map相关的方法
         *  Java8 flatMap相关的方法
     *  参考

## 别告诉我Java8都出来这么久了，你还搞不懂Stream的map和flatmap的区别？ ##

### Java8 map相关的方法 ###

/** * Returns a stream consisting of the results of applying the given * function to the elements of this stream. * * <p>This is an <a href="package-summary.html#StreamOps">intermediate * operation</a>. * * @param <R> The element type of the new stream * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * function to apply to each element * @return the new stream */
        <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    
        /** * Returns an {@code IntStream} consisting of the results of applying the * given function to the elements of this stream. * * <p>This is an <a href="package-summary.html#StreamOps"> * intermediate operation</a>. * * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * function to apply to each element * @return the new stream */
        IntStream mapToInt(ToIntFunction<? super T> mapper);
    
        /** * Returns a {@code LongStream} consisting of the results of applying the * given function to the elements of this stream. * * <p>This is an <a href="package-summary.html#StreamOps">intermediate * operation</a>. * * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * function to apply to each element * @return the new stream */
        LongStream mapToLong(ToLongFunction<? super T> mapper);
    
        /** * Returns a {@code DoubleStream} consisting of the results of applying the * given function to the elements of this stream. * * <p>This is an <a href="package-summary.html#StreamOps">intermediate * operation</a>. * * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * function to apply to each element * @return the new stream */
        DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

1.  `<R> Stream<R> map(Function<? super T, ? extends R> mapper);`
2.  `IntStream mapToInt(ToIntFunction<? super T> mapper);`
3.  `LongStream mapToLong(ToLongFunction<? super T> mapper);`
4.  `DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);`

> map: 对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素。这个方法有三个对于原始类型的变种方法，分别是：`mapToInt`，`mapToLong`和`mapToDouble`。这三个方法也比较好理解，比如`mapToInt`就是把原始Stream转换成一个新的Stream，这个新生成的Stream中的元素都是int类型。之所以会有这样三个变种方法，可以免除自动装箱/拆箱的额外消耗

最通用和使用最多的就是我们的map方法了。

我们主要就是研究一下这个map方法了。

/** * Returns a stream consisting of the results of applying the given * function to the elements of this stream. * * <p>This is an <a href="package-summary.html#StreamOps">intermediate * operation</a>. * * @param <R> The element type of the new stream * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * function to apply to each element * @return the new stream */
        <R> Stream<R> map(Function<? super T, ? extends R> mapper);

Stream 支持 map 方法，它会接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映 射成一个新的元素。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70]

示例：

@Test
        void test01(){ 
            List<String> words = Arrays.asList("Hello", "World");
            List<Integer> wordLens = words.stream()
                    .map(String::length) //转为字符串长度的集合
                    .collect(Collectors.toList());
            System.out.println(wordLens);
        }

运行结果：

[5, 5]

可以看到原先集合是两个元素，最后通过map之后出来的集合也是两个元素，所以他们是一个一一对应的映射关系。

### Java8 flatMap相关的方法 ###

/** * Returns a stream consisting of the results of replacing each element of * this stream with the contents of a mapped stream produced by applying * the provided mapping function to each element. Each mapped stream is * {@link java.util.stream.BaseStream#close() closed} after its contents * have been placed into this stream. (If a mapped stream is {@code null} * an empty stream is used, instead.) * * <p>This is an <a href="package-summary.html#StreamOps">intermediate * operation</a>. * * @apiNote * The {@code flatMap()} operation has the effect of applying a one-to-many * transformation to the elements of the stream, and then flattening the * resulting elements into a new stream. * * <p><b>Examples.</b> * * <p>If {@code orders} is a stream of purchase orders, and each purchase * order contains a collection of line items, then the following produces a * stream containing all the line items in all the orders: * <pre>{@code * orders.flatMap(order -> order.getLineItems().stream())... * }</pre> * * <p>If {@code path} is the path to a file, then the following produces a * stream of the {@code words} contained in that file: * <pre>{@code * Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8); * Stream<String> words = lines.flatMap(line -> Stream.of(line.split(" +"))); * }</pre> * The {@code mapper} function passed to {@code flatMap} splits a line, * using a simple regular expression, into an array of words, and then * creates a stream of words from that array. * * @param <R> The element type of the new stream * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * function to apply to each element which produces a stream * of new values * @return the new stream */
        <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
    
        /** * Returns an {@code IntStream} consisting of the results of replacing each * element of this stream with the contents of a mapped stream produced by * applying the provided mapping function to each element. Each mapped * stream is {@link java.util.stream.BaseStream#close() closed} after its * contents have been placed into this stream. (If a mapped stream is * {@code null} an empty stream is used, instead.) * * <p>This is an <a href="package-summary.html#StreamOps">intermediate * operation</a>. * * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * function to apply to each element which produces a stream * of new values * @return the new stream * @see #flatMap(Function) */
        IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
    
        /** * Returns an {@code LongStream} consisting of the results of replacing each * element of this stream with the contents of a mapped stream produced by * applying the provided mapping function to each element. Each mapped * stream is {@link java.util.stream.BaseStream#close() closed} after its * contents have been placed into this stream. (If a mapped stream is * {@code null} an empty stream is used, instead.) * * <p>This is an <a href="package-summary.html#StreamOps">intermediate * operation</a>. * * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * function to apply to each element which produces a stream * of new values * @return the new stream * @see #flatMap(Function) */
        LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
    
        /** * Returns an {@code DoubleStream} consisting of the results of replacing * each element of this stream with the contents of a mapped stream produced * by applying the provided mapping function to each element. Each mapped * stream is {@link java.util.stream.BaseStream#close() closed} after its * contents have placed been into this stream. (If a mapped stream is * {@code null} an empty stream is used, instead.) * * <p>This is an <a href="package-summary.html#StreamOps">intermediate * operation</a>. * * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>, * <a href="package-summary.html#Statelessness">stateless</a> * function to apply to each element which produces a stream * of new values * @return the new stream * @see #flatMap(Function) */
        DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);

> flatMap：和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 1]

示例：我们需要使用flatMap找出单词列表中各不相同的字符，比如我们现在有\[Hello, World\]这样一个集合，然后我们要找出单词列表中各不相同的字符，最后出来的结果是\[H, e, l, o, W, r, d\]

@Test
        void test02() { 
            //使用flatMap找出单词列表中各不相同的字符
            List<String> words = Arrays.asList("Hello", "World");
            List<String> wordMap = words.stream()
                    .map(word -> word.split(""))
                    .flatMap(Arrays::stream)
                    .distinct()
                    .collect(Collectors.toList());
            System.out.println(wordMap);
        }

运行结果：

[H, e, l, o, W, r, d]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 2]

flatmap 方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流。

## 参考 ##

[Java8初体验（二）Stream语法详解][Java8_Stream]

[Java8特性③Stream的使用][Java8_Stream 1]

[【Java 8 新特性】Java 8 Stream flatMapToInt, flatMapToLong和flatMapToDouble使用示例][Java 8 _Java 8 Stream flatMapToInt_ flatMapToLong_flatMapToDouble]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70]: /images/20221014/aebcc2e8c0b741a3b4aa029ba94fa03a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 1]: /images/20221014/91ea78ec5078417485f0ebae2a66e453.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 2]: /images/20221014/68c83815f4574e368eea6b472a6ab415.png
[Java8_Stream]: http://ifeve.com/stream/
[Java8_Stream 1]: https://segmentfault.com/a/1190000009270758
[Java 8 _Java 8 Stream flatMapToInt_ flatMapToLong_flatMapToDouble]: https://blog.csdn.net/qq_31635851/article/details/112376963

发表评论取消回复

表情：

评论列表（有 0 条评论，16人围观）

还没有评论，来说两句吧...

相关阅读

相关这么简单，还不会使用java8 stream流的map()方法吗？

一、前言在日常的开发工作中经常碰到要处理list中数据的问题，比如从数据库中查出了很多学生，由于一些原因需要在内存中找出这些学生中的所有姓名，或者把名为“王五”的语文成

水深无声/ 2024年03月31日 14:29/ 0 赞/ 14 阅读

相关 map 和 flatMap 的区别

一、map 和 flatMap 对应的源码 ① map方法 <R> Stream<R> map(Function<? super T, ? extends

川长思鸟来/ 2024年03月27日 14:59/ 0 赞/ 113 阅读

相关 java8中的map与flatmap区别

map:只能返回一个值 flatmap:返回多个值 new ArrayList().stream().map(x -> x);//返回一个 new ArrayList(

偏执的太偏执、/ 2023年10月01日 08:51/ 0 赞/ 34 阅读

相关朋友，别告诉我你懂分布式事务！

一、写在前面之前网上看到很多写分布式事务的文章，不过大多都是将分布式事务各种技术方案简单介绍一下。很多朋友看了不少文章，还是不知道分布式事务到底怎么回事，在项目里到底如

ゞ浴缸里的玫瑰/ 2023年02月25日 07:12/ 0 赞/ 28 阅读

相关你可能永远都搞不懂了图灵机了！

程序员都知道图灵机，但是却不一定能搞懂它，不一定理解它为什么这么厉害。 ![c25c2e240ea135989144ddec035e1127.png][] 原因就是：图灵机

川长思鸟来/ 2023年01月13日 04:29/ 0 赞/ 235 阅读

相关 java8 map()和flatMap()之间的区别

1.概述 map()和flatMap() 在Java 8中，可以在Optional，Stream和CompletableFuture中找到它们（尽管名称稍有不同）。流

爱被打了一巴掌/ 2022年11月15日 11:41/ 0 赞/ 33 阅读

相关 Java 8 Stream 的 flatMap

Java 8 的 Stream 的 flatMap 有点难用言语表示，我记录一个工作中的例子，读取一个文件中的 key 和 value 值。我把文件的每一行用一个数组表示，然后

╰半橙微兮°/ 2022年10月30日 12:29/ 0 赞/ 219 阅读

相关别告诉我Java8都出来这么久了，你还搞不懂Stream的map和flatmap的区别？

文章目录别告诉我Java8都出来这么久了，你还搞不懂Stream的map和flatmap的区别？ Java8 map相关的方法

桃扇骨/ 2022年10月16日 00:54/ 0 赞/ 17 阅读

相关 JAVA8 - Optional中map和flatMap的区别

map中获取的返回值自动被Optional包装,即返回值 -> Optional<返回值> flatMap中返回值保持不变,但必须是Optional类型,即Optional<

深藏阁楼爱情的钟/ 2022年05月20日 02:28/ 0 赞/ 404 阅读

相关 map和flatmap的区别

[为什么80%的码农都做不了架构师？>>> ][80_] ![hot3.png][] map函数会对每一条输入进行指定的操作，然后为每一条输入返回一个对象；而flatMap

缺乏、安全感/ 2022年01月15日 07:29/ 0 赞/ 276 阅读