当前位置: 首页 > 编程笔记 >

浅谈java8 stream flatMap流的扁平化操作

丁钟展
2023-03-14
本文向大家介绍浅谈java8 stream flatMap流的扁平化操作,包括了浅谈java8 stream flatMap流的扁平化操作的使用技巧和注意事项,需要的朋友参考一下

概念:

Steam 是Java8 提出的一个新概念,不是输入输出的 Stream 流,而是一种用函数式编程方式在集合类上进行复杂操作的工具。简而言之,是以内部迭代的方式处理集合数据的操作,内部迭代可以将更多的控制权交给集合类。Stream 和 Iterator 的功能类似,只是 Iterator 是以外部迭代的形式处理集合数据的操作。

在Java8以前,对集合的操作需要写出处理的过程,如在集合中筛选出满足条件的数据,需要一 一遍历集合中的每个元素,再把每个元素逐一判断是否满足条件,最后将满足条件的元素保存返回。而Stream 对集合筛选的操作提供了一种更为便捷的操作,只需将实现函数接口的筛选条件作为参数传递进来,Stream会自行操作并将合适的元素同样以stream 的方式返回,最后进行接收即可。

2种操作:

1.intermediate operation 中间操作:中间操作的结果是刻画、描述了一个Stream,并没有产生一个新集合,这种操作也叫做惰性求值方法。

2.terminal operation 终止操作:最终会从Stream中得到值。

如何区分这2种操作呢?可以根据操作的返回值类型判断,如果返回值是Stream,则该操作是中间操作,如果返回值是其他值或者为空,则该操作是终止操作。

flatMap 中间操作:

可用 Stream 替换值,并将多个 Stream 流合并成一个 Stream 流。

将含有一串数字的两个流合并为一个流,

 @Test
 public void flapMapTest() {
 List<Integer> list = (List<Integer>) Stream.of(Arrays.asList(1, 2, 3, 4, 5, 6), Arrays.asList(8, 9, 10, 11, 12))
  .flatMap(test -> test.stream()).collect(Collectors.toList());
 
 for (int i = 0, length = list.size(); i < length; i++) {
  System.out.println(list.get(i));
 }
 
 }

flatMap的用法和含义住要通过一个案例来讲解,

案例:对给定单词列表 ["Hello","World"],你想返回列表["H","e","l","o","W","r","d"]

第一种方式

String[] words = new String[]{"Hello","World"}; 
List<String[]> a = Arrays.stream(words)
 
.map(word -> word.split("")) 
.distinct() 
.collect(toList()); 
a.forEach(System.out::print);

代码输出为:

[Ljava.lang.String;@12edcd21[Ljava.lang.String;@34c45dca

(返回一个包含两个String[]的list)

这个实现方式是由问题的,传递给map方法的lambda为每个单词生成了一个String[](String列表)。因此,map返回的流实际上是Stream<String[]> 类型的。你真正想要的是用Stream<String>来表示一个字符串。

下方图是上方代码stream的运行流程

第二种方式:flatMap(对流扁平化处理)

String[] words = new String[]{"Hello","World"}; 
List<String> a = Arrays.stream(words)
 
.map(word -> word.split("")) 
.flatMap(Arrays::stream) 
.distinct() 
.collect(toList()); 
a.forEach(System.out::print);

结果输出:HeloWrd

使用flatMap方法的效果是,各个数组并不是分别映射一个流,而是映射成流的内容,所有使用map(Array::stream)时生成的单个流被合并起来,即扁平化为一个流。

下图是运用flatMap的stream运行流程,

示例:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class FlatMap {
  public static void main(String[] args) {
    //扁平化流
    //找出数组中唯一的字符
    String[] strArray = {"hello", "world"};
 
    //具体实现
    List<String> res = Arrays.stream(strArray)
        .map(w -> w.split(""))
        .flatMap(Arrays::stream)
        .distinct()
        .collect(Collectors.toList());
    System.out.println(res);
 
    //TODO 案例
    System.out.println("--------------------------------");
    //Demo1:给定数组,返回数组平方和(直接使用映射)
    //[1,2,3,4]=>[1,4,9,16]
    Integer[] nums1 = {1, 2, 3, 4};
    List<Integer> nums1List = Arrays.asList(nums1);
    List<Integer> res1 = nums1List.stream().map(i -> i * i).collect(Collectors.toList());
    System.out.println(res1);
 
    System.out.println("--------------------------------");
    //Demo2:给定两数组,返回数组对
    //[1,2,3],[3,4]=>[1,3],[1,4],[2,3],[2,4],[3,3],[3,4]
    Integer[] nums2 = {1, 2, 3};
    Integer[] nums3 = {3, 4};
    List<Integer> nums2List = Arrays.asList(nums2);
    List<Integer> nums3List = Arrays.asList(nums3);
 
    //使用2个map嵌套过滤
    List<int[]> res2 = nums2List.stream().flatMap(i -> nums3List.stream().map(j -> new int[]{i, j})).collect(Collectors.toList());
    System.out.println(res2.size());
 
    System.out.println("--------------------------------");
    //Demo3:针对Demo2和Demo1组合返回总和能被3整除的数对
    //(2,4)和(3,3)是满足条件的
    List<int[]> res3 = nums2List.stream().flatMap(i -> nums3List.stream().filter(j -> (i + j) % 3 == 0).map(j -> new int[]{i, j})).collect(Collectors.toList());
    System.out.println(res3.size()); 
  }
}

控制台输出结果:

补充知识:Java 之 Stream流中map和flatMap的区别

我们先来看 map。如果你熟悉 scala 这类函数式语言,对这个方法应该很了解,它的作用就是把 input Stream 的每一个元素,映射成 output Stream 的另外一个元素。

转换大写

List<String> output = wordList.stream().
map(String::toUpperCase).
collect(Collectors.toList());

这段代码把所有的单词转换为大写。

平方数

List<Integer> nums = Arrays.asList(1, 2, 3, 4);
List<Integer> squareNums = nums.stream().
map(n -> n * n).
collect(Collectors.toList());

这段代码生成一个整数 list 的平方数 {1, 4, 9, 16}。

从上面例子可以看出,map 生成的是个 1:1 映射,每个输入元素,都按照规则转换成为另外一个元素。还有一些场景,是一对多映射关系的,这时需要 flatMap。

一对多

Stream<List<Integer>> inputStream = Stream.of(
 Arrays.asList(1),
 Arrays.asList(2, 3),
 Arrays.asList(4, 5, 6)
 );
Stream<Integer> outputStream = inputStream.
flatMap((childList) -> childList.stream());

flatMap 把 inpuStream 中的层级结构扁平化,就是将最底层元素抽出来放到一起,最终 output 的新 Stream 里面已经没有 List 了,都是直接的数字。

以上这篇浅谈java8 stream flatMap流的扁平化操作就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持小牛知识库。

 类似资料:
  • 我想在指定年份之间的一年做一个季度的笛卡尔积 年度(2105、2016)应返回季度(2015、Q1)、季度(2015、Q2)...季度(2016年第四季度) 我想出的代码如下所示 上面的代码返回,我需要将其扁平化为。

  • 问题内容: 我有一个这样的清单: 此列表中的每个项目可能包含一个数据对或一个元组,我想将此列表更改为 然后这样做: 我不知道如何更改列表结构,或者如何基于原始列表进行相同的计算? 问题答案: 如果您只想整理列表,请使用:http : //docs.python.org/library/itertools.html#itertools.chain.from_iterable

  • 本文向大家介绍Python分组扁平化列表,包括了Python分组扁平化列表的使用技巧和注意事项,需要的朋友参考一下 在本教程中,我们将编写一个程序,将包含子列表的列表展开。给定的数字将子列表展开,直到给定的数字索引作为部分。让我们看一个例子来清楚地理解它。 输入项 输出结果 让我们看看解决问题的步骤。 初始化列表和编号。 初始化一个空列表。 使用范围(0,len(lists),number遍历列表

  • 问题内容: 我在这里发现了同样的问题… …但是没有正确的答案。 最好的建议之一是将嵌套对象包装到新类中,但是这种方法引入了另一个问题:乐高名称。 在我的示例中,此类的最逻辑名称是与父类相同的名称,当然这是不可能的。我的示例很简单,我只想消除父类中的“语言”属性。有人可以帮我做吗? json的示例: 问题答案: 如果JSON属性名称与c#命名约定冲突,则可以在序列化期间使用或批注替换其他名称。 例如

  • 我有一个类别树,由以下内容表示。 这给出了一个dataframe,如下所示: 树中最高的节点的parent_id等于-1,因此树可以用图形表示如下: 我需要生成以下DataFrame。 该树是动态生成的,可以具有任意数量的级别,因此下面的树 应产生以下结果:

  • 本文向大家介绍JS数组扁平化、去重、排序操作实例详解,包括了JS数组扁平化、去重、排序操作实例详解的使用技巧和注意事项,需要的朋友参考一下 本文实例讲述了JS数组扁平化、去重、排序操作。分享给大家供大家参考,具体如下: 在网上看到一个校招题目,已知一个数组var arr = [[1, 3, 2, 1],[5, 3, 4, 8, 5, 6, 5],[6, 2, 8, 9, [4, 11, 15, 8