概念：
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 流。
将含有一串数字的两个流合并为一个流，
|
1
2
3
4
5
6
7
8
9
10
|
@Testpublic 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"]
第一种方式
|
1
2
3
4
5
6
7
|
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（对流扁平化处理）
|
1
2
3
4
5
6
7
8
|
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运行流程，
示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
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 的另外一个元素。
转换大写
|
1
2
3
|
List<String> output = wordList.stream().map(String::toUpperCase).collect(Collectors.toList()); |
这段代码把所有的单词转换为大写。
平方数
|
1
2
3
4
|
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。
一对多
|
1
2
3
4
5
6
7
|
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流的扁平化操作就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/ZYC88888/article/details/90377010
