Java8 Stream用法总结

Java8 Stream

Stream 总览
- 什么是流
- 流的构成
- 流的构造与转换
- - 构造流的几种常见方法
  - 流转换为其它数据结构
- 中间操作符
- - map
  - mapToInt
  - mapToLong、mapToDouble 与mapToInt 类似
  - flatmap
  - limit
  - distinct
  - filter
  - skip
  - sorted
- 终止操作符
- - collect(核心)
  - count
  - findFirst
  - findAny
  - Match
  - min
  - max
  - forEachOrdered
- Collector 收集器(重点)
- - 使用Collectors生成Map
  - 使用Collectors做字符串join
  - 使用Collectors统计
- Optional
- 其他补充
- - iterate
  - Stream Trace(debug调试Stream)
- 特性总结

Stream 总览

什么是流

Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。

Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。

而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。顾名思义，当使用串行方式去遍历时，每个 item 读完后再读下一个 item。而使用并行去遍历时，数据会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。Stream 的并行操作依赖于 Java7 中引入的 Fork/Join 框架（JSR166y）来拆分任务和加速处理过程。Java 的并行 API 演变历程基本如下：

1.0-1.4 中的 java.lang.Thread
5.0 中的 java.util.concurrent
6.0 中的 Phasers 等
7.0 中的 Fork/Join 框架
8.0 中的 Lambda

流的构成

当我们使用一个流的时候，通常包括三个基本步骤：

获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道，如下图所示。

图 1. 流管道 (Stream Pipeline) 的构成

有多种方式生成 Stream Source：

从 Collection 和数组
。Collection.stream()
。Collection.parallelStream()
。Arrays.stream(T array) or Stream.of()
静态工厂
。 java.util.stream.IntStream.range()
。 java.nio.file.Files.walk()
自己构建
。java.util.Spliterator
。其它
。Random.ints()
。BitSet.stream()
。Pattern.splitAsStream(java.lang.CharSequence)
。JarFile.stream()

流的操作类型分为两种：

Intermediate(中间操作符)：一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
Terminal（终止操作符）：一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的
最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个 side effect

在对于一个 Stream 进行多次转换操作 (Intermediate 操作)，每次都对 Stream 的每个元素进行转换，而且是执行多次，这样时间复杂度就是 N（转换次数）个 for 循环里把所有操作都做掉的总和吗？其实不是这样的，转换操作都是 lazy 的，多个转换操作只会在 Terminal 操作的时候融合起来，一次循环完成。我们可以这样简单的理解，Stream 里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在 Terminal 操作的时候循环 Stream 对应的集合，然后对每个元素执行所有的函数。

简单说，对 Stream 的使用就是实现一个 filter-map-reduce 过程，产生一个最终结果，或者导致一个副作用（side effect）。

流的构造与转换

下面提供最常见的几种构造 Stream 的样例。

构造流的几种常见方法

// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();

需要注意的是，对于基本数值型，目前有三种对应的包装类型 Stream：

IntStream、LongStream、DoubleStream。

流转换为其它数据结构

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

一个 Stream 只可以使用一次，上面的代码为了简洁而重复使用了数次。

中间操作符

对于数据流来说，中间操作符在执行制定处理程序后，数据流依然可以传递给下一级的操作符。
中间操作符包含8种(排除了parallel,sequential,这两个操作并不涉及到对数据流的加工操作)：

map(mapToInt,mapToLong,mapToDouble) 转换操作符，把比如A->B，这里默认提供了转int，long，double的操作符。

flatmap(flatmapToInt,flatmapToLong,flatmapToDouble) 拍平操作比如把 int[]{2,3,4} 拍平变成 2，3，4 也就是从原来的一个数据变成了3个数据，这里默认提供了拍平成int,long,double的操作符。

limit 限流操作，比如数据流中有10个我只要出前3个就可以使用。

distint 去重操作，对重复元素去重，底层使用了equals方法。

filter 过滤操作，把不想要的数据过滤。

peek 挑出操作，如果想对数据进行某些操作，如：读取、编辑修改等。

skip 跳过操作，跳过某些元素。

sorted(unordered) 排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器。

map

1、简单使用，map操作将原来的单词转换成了每个单的长度，利用了String自身的length()方法，该方法返回类型为int。

public class Main {public static void main(String[] args) {Stream.of("apple","banana","orange","waltermaleon","grape").map(String::length) //转成单词的长度 int.forEach(System.out::println);}
}

结果如图：

2、对象属性提取
将UserVO对象中的name属性提取成数组

public static void main(String[] args) {List<UserVO> userVOs = new ArrayList<>();userVOs.add(new UserVO("张三", 13));userVOs.add(new UserVO("李四", 15));userVOs.add(new UserVO("王五", 18));testStreamMap(userVOs);}public static void testStreamMap(List<UserVO> userVOs) {List<String> userNames = userVOs.stream().map(UserVO::getName).collect(Collectors.toList());userNames.stream().forEach(item-> System.out.println(item));}

3、根据属性构建对象

public static void testStreamMap2() {Stream.of("张三", "李四", "王五").map(s -> new UserVO(s, 18)).forEach(item-> System.out.println(item.getName()));}

4、转换大写

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

5、平方数

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

mapToInt

将数据流中得元素转成Int，这限定了转换的类型Int，最终产生的流为IntStream，及结果只能转化成int。

public class Main {public static void main(String[] args) {Stream.of("apple", "banana", "orange", "waltermaleon", "grape").mapToInt(e -> e.length()) //转成int.forEach(e -> System.out.println(e));}
}

mapToLong、mapToDouble 与mapToInt 类似

flatmap

flatmap 作用就是将元素拍平拍扁，将拍扁的元素重新组成Stream，并将这些Stream 串行合并成一条Stream。

public class Main {public static void main(String[] args) {Stream.of("a-b-c-d","e-f-i-g-h").flatMap(e->Stream.of(e.split("-"))).forEach(e->System.out.println(e));}
}

limit

限制元素的个数，只需传入 long 类型表示限制的最大数

public class Main {public static void main(String[] args) {Stream.of(1,2,3,4,5,6).limit(3) //限制三个.forEach(e->System.out.println(e)); //将输出 前三个 1，2，3}
}

distinct

去重

public class Main {public static void main(String[] args) {Stream.of(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1).distinct() //去重.forEach(e->System.out.println(e));}
}

filter

对某些元素进行过滤，不符合筛选条件的将无法进入流的下游

public class Main {public static void main(String[] args) {Stream.of(1,2,3,1,2,5,6,7,8,0,0,1,2,3,1).filter(e->e>=5) //过滤小于5的.forEach(e->System.out.println(e));}
}

skip

跳过元素

public class Main {public static void main(String[] args) {Stream.of(1,2,3,4,5,6,7,8,9).skip(4) //跳过前四个.forEach(e->System.out.println(e)); //输出的结果应该只有5，6，7，8，9}
}

sorted

排序底层依赖Comparable 实现，也可以提供自定义比较器。
对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。

1、简单排序

public class Main {public static void main(String[] args) {Stream.of(2,1,3,6,4,9,6,8,0).sorted().forEach(e->System.out.println(e));}
}

2、根据对象中字段排序

//正序
List<UserVO> sortedList = list.stream().sorted(Comparator.comparing(UserVO::getAge)).collect(Collectors.toList());
//倒序
List<UserVO> reverseSortedList = list.stream().sorted(Comparator.comparing(UserVO::getAge).reversed()).collect(Collectors.toList());

3、排序字段中有空值避免NPE的处理

//nullsLast代表null值的排在后面，对应的还有nullsFirst，空值排在前面。
List<UserBasicInfo> sortedUserList = ywUsers.stream().sorted(Comparator.comparing(UserBasicInfo::getJobNumber, Comparator.nullsLast(String::compareTo))).collect(Collectors.toList());

终止操作符

数据经过中间加工操作，就轮到终止操作符上场了；终止操作符就是用来对数据进行收集或者消费的，数据到了终止操作这里就不会向下流动了，终止操作符只能使用一次。

collect 收集操作，将所有数据收集起来，这个操作非常重要，官方的提供的Collectors 提供了非常多收集器，可以说Stream 的核心在于Collectors。

count 统计操作，统计最终的数据个数。

findFirst、findAny 查找操作，查找第一个、查找任何一个返回的类型为Optional。

noneMatch、allMatch、anyMatch 匹配操作，数据流中是否存在符合条件的元素返回值为bool 值。

min、max 最值操作，需要自定义比较器，返回数据流中最大最小的值。

reduce 规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce。

forEach、forEachOrdered 遍历操作，这里就是对最终的数据进行消费了。

toArray 数组操作，将数据流的元素转换成数组。

collect(核心)

收集，使用系统提供的收集器可以将最终的数据流收集到List，Set，Map等容器中。
1、简单例子

public class Main {public static void main(String[] args) {Stream.of("apple", "banana", "orange", "waltermaleon", "grape").collect(Collectors.toSet()) //set 容器.forEach(e -> System.out.println(e));}
}

2、将Stream转换成容器或Map

// 将Stream转换成容器或Map
Stream<String> stream = Stream.of("I", "love", "you", "too");
List<String> list = stream.collect(Collectors.toList()); // (1)
Set<String> set = stream.collect(Collectors.toSet()); // (2)
Map<String, Integer> map = stream.collect(Collectors.toMap(Function.identity(), String::length)); // (3)

上述代码分别列举了如何将Stream转换成List、Set和Map。虽然代码语义很明确，可是我们仍然会有几个疑问：

Function.identity()是干什么的？
String::length是什么意思？
Collectors是个什么东西？

接口的静态方法和默认方法
Function是一个接口，那么Function.identity()是什么意思呢？这要从两方面解释：

1.Java 8允许在接口中加入具体方法。接口中的具体方法有两种，default方法和static方法，identity()就是Function接口的一个静态方法。
2.Function.identity()返回一个输出跟输入一样的Lambda表达式对象，等价于形如t -> t形式的Lambda表达式。

上面的解释是不是让你疑问更多？不要问我为什么接口中可以有具体方法，也不要告诉我你觉得t -> t比identity()方法更直观。我会告诉你接口中的default方法是一个无奈之举，在Java 7及之前要想在定义好的接口中加入新的抽象方法是很困难甚至不可能的，因为所有实现了该接口的类都要重新实现。试想在Collection接口中加入一个stream()抽象方法会怎样？default方法就是用来解决这个尴尬问题的，直接在接口中实现新加入的方法。既然已经引入了default方法，为何不再加入static方法来避免专门的工具类呢！

方法引用
诸如String::length的语法形式叫做方法引用（method references），这种语法用来替代某些特定形式Lambda表达式

count

统计数据流中的元素个数，返回的是long 类型。

public class Main {public static void main(String[] args) {long count = Stream.of("apple", "banana", "orange", "waltermaleon", "grape").count();System.out.println(count);}
}

findFirst

获取流中的第一个元素，或者空。

这里比较重点的是它的返回值类型：Optional。这也是一个模仿 Scala 语言中的概念，作为一个容器，它可能含有某值，或者不包含。使用它的目的是尽可能避免 NullPointerException。

public class FindFirst {public static void main(String[] args) {Optional<String> stringOptional = Stream.of("apple", "banana", "orange", "waltermaleon", "grape").findFirst();stringOptional.ifPresent(e->System.out.println(e));}
}

findAny

获取流中任意一个元素。

public class FindAny {public static void main(String[] args) {Optional<String> stringOptional = Stream.of("apple", "banana", "orange", "waltermaleon", "grape").parallel().findAny(); //在并行流下每次返回的结果可能一样也可能不一样stringOptional.ifPresent(e->System.out.println(e));}
}

Match

Stream 有三个 match 方法，从语义上说：

allMatch：Stream 中全部元素符合传入的 predicate，返回 true
anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

noneMatch数据流中得没有一个元素与条件匹配的。

public class NoneMatch {public static void main(String[] args) {boolean result = Stream.of("aa","bb","cc","aa").noneMatch(e->e.equals("aa"));System.out.println(result);}
}

allMatch、anyMatch

List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);

输出:

All are adult? false
Any child? true

min

最小的一个，传入比较器，也可能没有(如果数据流为空)

public class Main {public static void main(String[] args) {Optional<Integer> integerOptional = Stream.of(0,9,8,4,5,6,-1).min((e1,e2)->e1.compareTo(e2));integerOptional.ifPresent(e->System.out.println(e));}

max

元素中最大的，需要传入比较器，也可能没有（流为Empty时）。

public class Main {public static void main(String[] args) {Optional<Integer> integerOptional = Stream.of(0,9,8,4,5,6,-1).max((e1,e2)->e1.compareTo(e2));integerOptional.ifPresent(e->System.out.println(e));}
}

forEachOrdered

适用用于并行流的情况下进行迭代，能保证迭代的有序性。

public class ForEachOrdered {public static void main(String[] args) {Stream.of(0,2,6,5,4,9,8,-1).parallel().forEachOrdered(e->{System.out.println(Thread.currentThread().getName()+": "+e);});}
}

Collector 收集器(重点)

收集器（Collector）是为Stream.collect()方法量身打造的工具接口（类）。

使用Collectors生成Map

前面已经说过Stream背后依赖于某种数据源，数据源可以是数组、容器等，但不能是Map。反过来从Stream生成Map是可以的，但我们要想清楚Map的key和value分别代表什么，根本原因是我们要想清楚要干什么。通常在三种情况下collect()的结果会是Map：

1.使用Collectors.toMap()生成的收集器，用户需要指定如何生成Map的key和value。
2.使用Collectors.partitioningBy()生成的收集器，对元素进行二分区操作时用到。
3.使用Collectors.groupingBy()生成的收集器，对元素做group操作时用到。

情况1：使用toMap()生成的收集器，这种情况是最直接的，前面例子中已提到，这是和Collectors.toCollection()并列的方法。如下代码展示将学生列表转换成由<学生，GPA>组成的Map。非常直观，无需多言。

// 使用toMap()统计学生GPA
Map<Student, Double> studentToGPA =students.stream().collect(Collectors.toMap(Functions.identity(),// 如何生成keystudent -> computeGPA(student)));// 如何生成value

情况2：使用partitioningBy()生成的收集器，这种情况适用于将Stream中的元素依据某个二值逻辑（满足条件，或不满足）分成互补相交的两部分，比如男女性别、成绩及格与否等。下列代码展示将学生分成成绩及格或不及格的两部分。

// Partition students into passing and failing
Map<Boolean, List<Student>> passingFailing = students.stream().collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

情况3：使用groupingBy()生成的收集器，这是比较灵活的一种情况。跟SQL中的group by语句类似，这里的groupingBy()也是按照某个属性对数据进行分组，属性相同的元素会被对应到Map的同一个key上。下列代码展示将员工按照部门进行分组：

// Group employees by department
Map<Department, List<Employee>> byDept = employees.stream().collect(Collectors.groupingBy(Employee::getDepartment));

以上只是分组的最基本用法，有些时候仅仅分组是不够的。在SQL中使用group by是为了协助其他查询，比如1. 先将员工按照部门分组，2. 然后统计每个部门员工的人数。Java类库设计者也考虑到了这种情况，增强版的groupingBy()能够满足这种需求。增强版的groupingBy()允许我们对元素分组之后再执行某种运算，比如求和、计数、平均值、类型转换等。这种先将元素分组的收集器叫做上游收集器，之后执行其他运算的收集器叫做下游收集器(downstream Collector)。

// 使用下游收集器统计每个部门的人数
Map<Department, Integer> totalByDept = employees.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting()));// 下游收集器

上面代码的逻辑是不是越看越像SQL？高度非结构化。还有更狠的，下游收集器还可以包含更下游的收集器，这绝不是为了炫技而增加的把戏，而是实际场景需要。考虑将员工按照部门分组的场景，如果我们想得到每个员工的名字（字符串），而不是一个个Employee对象，可通过如下方式做到：

// 按照部门对员工分布组，并只保留员工的名字
Map<Department, List<String>> byDept = employees.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.mapping(Employee::getName,// 下游收集器Collectors.toList())));// 更下游的收集器

使用Collectors做字符串join

这个肯定是大家喜闻乐见的功能，字符串拼接时使用Collectors.joining()生成的收集器，从此告别for循环。Collectors.joining()方法有三种重写形式，分别对应三种不同的拼接方式。无需多言，代码过目难忘。

// 使用Collectors.joining()拼接字符串
Stream<String> stream = Stream.of("I", "love", "you");
//String joined = stream.collect(Collectors.joining());// "Iloveyou"
//String joined = stream.collect(Collectors.joining(","));// "I,love,you"
String joined = stream.collect(Collectors.joining(",", "{", "}"));// "{I,love,you}"

使用Collectors统计

1、对象属性求和（summingInt、summingLong、summingDouble）

public static void testStreamSummingInt(List<UserVO> userVOs) {Integer total = userVOs.stream().collect(Collectors.summingInt(UserVO::getAge));System.out.println(total);}

2、SummaryStatistics（数量统计count、求和sum、最小值min、平均值average、最大值max）

public static void testStreamSummarizing(List<UserVO> userVOs) {IntSummaryStatistics intSummaryStatistics = userVOs.stream().collect(Collectors.summarizingInt(UserVO::getAge));System.out.println(JSON.toJSONString(intSummaryStatistics));}

输出：
{“average”:19.11111111111111,“count”:9,“max”:30,“min”:13,“sum”:172}

3、BigDecimal类型统计

BigDecimal reduce = collectionPlans.stream().map(CrmContractCollectionPlan::getCollectionMoney).reduce(BigDecimal.ZERO, BigDecimal::add);

Optional

这也是一个模仿 Scala 语言中的概念，作为一个容器，它可能含有某值，或者不包含。使用它的目的是尽可能避免 NullPointerException。

Optional 的两个用例

String strA = " abcd ", strB = null;
print(strA);
print("");
print(strB);
getLength(strA);
getLength("");
getLength(strB);
public static void print(String text) {// Java 8Optional.ofNullable(text).ifPresent(System.out::println);// Pre-Java 8if (text != null) {System.out.println(text);}}
public static int getLength(String text) {// Java 8
return Optional.ofNullable(text).map(String::length).orElse(-1);// Pre-Java 8
// return if (text != null) ? text.length() : -1;};

在更复杂的 if (xx != null) 的情况中，使用 Optional 代码的可读性更好，而且它提供的是编译时检查，能极大的降低 NPE 这种 Runtime Exception 对程序的影响，或者迫使程序员更早的在编码阶段处理空值问题，而不是留到运行时再发现和调试。

Stream 中的 findAny、max/min、reduce 等方法等返回 Optional 值。还有例如 IntStream.average() 返回 OptionalDouble 等等。

其他补充

iterate

生成一个等差数列

Stream.iterate(0, n -> n + 3).limit(10). forEach(x -> System.out.print(x + " "));

输出：

0 3 6 9 12 15 18 21 24 27

Stream Trace(debug调试Stream)

Java的Stream编程给调试带来了极大的不便，idea 推出了Stream Trace功能，可以详细看到每一步操作的关系、结果，非常方便进行调试。

StreamTrace只有在debug模式下才能使用，当在Stream代码上设置断点后，启动debug，点击流按钮，如图所示。

测试代码

public static void testStreamTrace(List<UserVO> userVOs) {List<Integer> ages = userVOs.stream().map(UserVO::getAge).filter(age->age<20).distinct().sorted().collect(Collectors.toList());System.out.println(JSON.toJSONString(ages));}

两种展示方式
1.Split Mode
分别展示每一步的结果

2.Flat Mode
全局展示整个流的每个环节

特性总结

不是数据结构
它没有内部存储，它只是用操作管道从 source（数据结构、数组、generator function、IO channel）抓取数据。
它也绝不修改自己所封装的底层数据结构的数据。例如 Stream 的 filter 操作会产生一个不包含被过滤元素的新 Stream，而不是从 source 删除那些元素。
所有 Stream 的操作必须以 lambda 表达式为参数。
不支持索引访问。
你可以请求第一个元素，但无法请求第二个，第三个，或最后一个。不过请参阅下一项。
很容易生成数组或者 List。
惰性化。
很多 Stream 操作是向后延迟的，一直到它弄清楚了最后需要多少数据才会开始。
Intermediate 操作永远是惰性化的。
并行能力。
当一个 Stream 是并行化的，就不需要再写多线程代码，所有对它的操作会自动并行进行的。
可以是无限的。
集合有固定大小，Stream 则不必。limit(n) 和 findFirst() 这类的 short-circuiting 操作可以对无限的 Stream 进行运算并很快完成。

参考文献：https://blog.csdn.net/weixin_43994761/article/details/90025385
https://www.jianshu.com/p/11c925cdba50