Java8 Stream流操作最强详解版
### 1. Stream简介
Java8 是Java 最受欢迎的一个版本，Stream是Java8提供的一个新的API，它位于java.util.stream包下。Stream API提供了一种新的方式来对Java集合进行操作，给我们操作集合（Collection）提供了极大的便利。其中的Stream流是JDK8新增的成员，是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以将元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等操作。元素流在管道中经过中间操作的处理，最后由最终操作得到前面处理的结果。Stream API 提供了一种高效且易于使用的处理数据的方式。
### 2. Stream概述
#### 2.1 Stream特性
```java
1.stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
2.stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
3.stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。
```
#### 2.2 Stream特点
```java
1.代码简洁：函数编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。
2.多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。
3.Stream不存储数据
4.Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
5.Stream是惰性求值的（延迟执行）
```
### 3. Stream创建
#### 3.1 创建步骤
```java
1.创建 Stream
一个数据源（如： 集合、数组）， 获取一个流。
2.中间操作
一个中间操作链，对数据源的数据进行处理。
3.终止操作(终端操作)
一个终止操作，执行中间操作链，并产生结果 。
```
#### 3.2 创建实例
1.通过 `java.util.Collection.stream()` 方法用集合创建流
```java
List list = new ArrayList<>();
//获取一个顺序流
Stream stream = list.stream();
//获取一个并行流
Stream parallelStream = list.parallelStream();
```
2.使用`java.util.Arrays.stream(T[] array)`方法用数组创建流
```java
int[] array = {1, 3, 5, 7, 9};
IntStream stream = Arrays.stream(array);
```
3.使用`Stream`的静态方法：`of()、iterate()、generate()`
```java
Stream stream = Stream.of(1, 2, 3, 4, 5);
stream.forEach(System.out::println);
Stream stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);
Stream stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);
```
### 4. Stream流程
```bash
1）第一步：把集合转换为流stream
2）第二步：操作stream流
stream流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果
获取一个数据源（source）→ 数据转换→执行操作获取想要的结果。
```
### 5. Steam的使用
#### 5.1 遍历/匹配
（foreach/find/match）操作
```java
List listNum = Arrays.asList(1, 2, 3, 8, 9, 5, 7);
// 遍历输出符合条件的元素
listNum.stream().filter(x -> x > 7).forEach(System.out::println);
// 符合条件的元素匹配第一个
Optional findFirst = listNum.stream().filter(x -> x > 7).findFirst();
// 符合条件的元素匹配任意（适用于并行流）
Optional findAny = listNum.parallelStream().filter(x -> x > 7).findAny();
// 是否包含符合特定条件的元素
boolean anyMatch = listNum.stream().anyMatch(x -> x > 7);
System.out.println("匹配第一个值：" + findFirst.get());
System.out.println("匹配任意一个值：" + findAny.get());
System.out.println("是否存在大于6的值：" + anyMatch);
//结果
8
9
匹配第一个值：8
匹配任意一个值：9
是否存在大于6的值：true
```
#### 5.2 中间操作
| | 流方法 | 含义 |
| --- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1 | filter | 用于通过设置的条件过滤出元素 |
| 2 | distinct | 返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流。 |
| 3 | limit | 会返回一个不超过给定长度的流。 |
| 4 | skip | 返回一个扔掉了前n个元素的流。 |
| 5 | map | 接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）。 |
| 6 | flatMap | 使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流。 |
| 7 | sorted | 返回排序后的流 |
##### 5.2.1 筛选（filter）
按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。
```java
//案例一：筛选出Integer集合中大于6的元素，并打印出来。
public static void main(String[] args) {
List list = Arrays.asList(0, 6, 3, 5, 1, 2, 9, 7, 8);
Stream stream = list.stream();
stream.filter(x -> x > 6).forEach(System.out::println);
}
//结果
9
7
8
//案例二：筛选出Person集合中年龄大于19员工姓名的元素，并打印出来。
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(1, "zhangsan", 18, "shanghai"));
personList.add(new Person(2, "lisi", 19, "beijing"));
personList.add(new Person(3, "wanger", 20, "guangdong"));
personList.add(new Person(4, "mazi", 21, "jiangxi"));
personList.add(new Person(5, "laoer", 22, "zhejiang"));
List filterList = personList.stream().filter(x -> x.getAge() > 19).map(Person::getName)
.collect(Collectors.toList());
System.out.print("年龄大于19员工姓名：" + filterList);
}
//结果
年龄大于19员工姓名：[wanger, mazi, laoer]
```
##### 5.2.2 去重(distinct)
通过流中元素的 `hashCode()` 和 `equals()` 去除重复元素
```java
//去除重复元素
public static void main(String[] args) {
List list = Arrays.asList(0, 6, 3, 5, 1, 2, 9, 7, 8);
Stream stream = list.stream();
stream.filter(x -> x > 6).distinct().forEach(System.out::println);
}
//结果
9
7
8
```
##### 5.2.3 跳过元素limit(n)
跳过n元素，配合`limit(n)`可实现分页
```java
//跳过前两个元素
public static void main(String[] args) {
List list = Arrays.asList(0, 6, 3, 5, 1, 2, 9, 7, 8);
Stream stream = list.stream();
stream.filter(x -> x > 6).skip(2).forEach(System.out::println);
}
//结果
8
```
##### 5.2.4 获取元素skip(n)
获取n个元素
```java
//获取第几个元素
public static void main(String[] args) {
List list = Arrays.asList(0, 6, 3, 5, 1, 2, 9, 7, 8);
Stream stream = list.stream();
stream.filter(x -> x > 6).limit(2).forEach(System.out::println);
}
//结果
9
7
```
##### 5.2.5 映射(map/flatMap)
可以将一个流的元素按照一定的映射规则映射到另一个流中
* **map：** 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
* **flatMap：** 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
其实map方法就相当于Collaction的add方法，如果add的是个集合得话就会变成二维数组，而flatMap 的话就相当于Collaction的addAll方法，参数如果是集合得话，只是将2个集合合并，而不是变成二维数组。
```java
//案列一:整个数组的数组元素+10
public static void main(String[] args) {
List list = Arrays.asList(1, 2, 3, 4);
List collect = list.stream().map(x -> x + 10).collect(Collectors.toList());
System.out.println(collect);
}
//结果
[11, 12, 13, 14]
//案列二:将两个字符数组合并成一个新的字符数组。
public static void main(String[] args) {
List list = Arrays.asList("a,b,c,d", "e,f,g,h");
List listNew = list.stream().flatMap(s -> {
// 将每个元素转换成一个stream
String[] split = s.split(",");
Stream s2 = Arrays.stream(split);
return s2;
}).collect(Collectors.toList());
System.out.println("转换前的数据：" + list);
System.out.println("转换后后的数据：" + listNew);
}
//结果
转换前的数据：[a,b,c,d, e,f,g,h]
转换后后的数据：[a, b, c, d, e, f, g, h]
//案列三:将集合里的元素由小写变大写：
List list = Arrays.asList("a", "b", "c", "d");
List results = list.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println(results);
//结果
{A, B, C, D}
//案列四:每个员工工资加3000
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(1, "zhangsan", 18, 4000, "shanghai"));
personList.add(new Person(2, "lisi", 19, 5000, "beijing"));
personList.add(new Person(3, "wanger", 20, 6000, "guangdong"));
personList.add(new Person(4, "mazi", 21, 7000, "jiangxi"));
personList.add(new Person(5, "laoer", 22, 8000, "zhejiang"));
// 不改变原来员工工资集合的方式
List personListNew = personList.stream().map(person -> {
Person personNew = new Person(0, person.getName(), 0, 0, null);
personNew.setSalary(person.getSalary() + 3000);
return personNew;
}).collect(Collectors.toList());
System.out.println("一次改动前：" +
personList.get(0).getName() + "-->" + personList.get(0).getSalary());
System.out.println("一次改动后：" +
personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());
// 改变原来员工工资集合的方式
List personListNew2 = personList.stream().map(person -> {
person.setSalary(person.getSalary() + 3000);
return person;
}).collect(Collectors.toList());
System.out.println("二次改动前：" +
personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());
System.out.println("二次改动后：" +
personListNew2.get(0).getName() + "-->" + personListNew.get(0).getSalary());
}
@Data
static class Person {
private int id;
private String name;
private int age;
private int salary;
private String address;
public Person(int id, String name, int age, int salary, String address) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
this.address = address;
}
}
//结果
一次改动前：zhangsan-->4000
一次改动后：zhangsan-->14000
二次改动前：zhangsan-->14000
二次改动后：zhangsan-->14000
```
##### 5.2.6 排序(sorted)
sorted，中间操作。有两种排序：
* sorted()：自然排序，流中元素需实现 Comparable 接口
* sorted(Comparator com)：Comparator 排序器自定义排序
```java
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(1, "zhangsan", 18, 4000, "shanghai"));
personList.add(new Person(2, "lisi", 19, 5000, "beijing"));
personList.add(new Person(3, "wanger", 20, 6000, "guangdong"));
personList.add(new Person(4, "mazi", 21, 7000, "jiangxi"));
personList.add(new Person(5, "laoer", 22, 8000, "zhejiang"));
//工资排序顺序
List collect1 = personList.stream().sorted(Comparator.comparing(Person::getSalary)).collect(Collectors.toList());
collect1.forEach(System.out::println);
}
//结果
test12.Person(id=1, name=zhangsan, age=18, salary=4000, address=shanghai)
test12.Person(id=2, name=lisi, age=19, salary=5000, address=beijing)
test12.Person(id=3, name=wanger, age=20, salary=6000, address=guangdong)
test12.Person(id=4, name=mazi, age=21, salary=7000, address=jiangxi)
test12.Person(id=5, name=laoer, age=22, salary=8000, address=zhejiang)
```
sorted排序参考模板
```java
//返回 对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));
//返回 对象集合以类属性一降序排序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序
//返回 对象集合以类属性一升序 属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));
//返回 对象集合以类属性一降序 属性二升序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序
//返回 对象集合以类属性一降序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序
//返回 对象集合以类属性一升序 属性二降序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序
```
#### 5.3 终止操作
| | 流方法 | 含义 |
| --- | --------------- | ------------------------------------------ |
| 1 | anyMatch | 检查是否至少匹配一个元素，返回boolean。 |
| 2 | allMatch | 检查是否匹配所有元素，返回boolean。 |
| 3 | noneMatch | 检查是否没有匹配所有元素，返回boolean。 |
| 4 | findAny | 将返回当前流中的任意元素。 |
| 5 | findFirst | 返回第一个元素 |
| 6 | forEach | 遍历流 |
| 7 | collect | 收集器，将流转换为其他形式。 |
| 8 | reduce | 可以将流中元素反复结合起来，得到一个值。 |
| 9 | max/min/count | 返回流中元素最大/最小/总数。 |
##### 5.3.2 收集(collect)
###### ①归集(toList/toSet/toMap)
```java
转化成新的List
List<> new = old.stream().collect(Collectors.toList());
转化成Map
Map new= old.stream().collect(Collectors.toMap(T,E));
转换成set集合
Set<> new =old.stream().Collectors.toSet();
转换成特定的set集合
TreeSet<> new =old.stream().Collectors.toCollection(TreeSet::new);
```
转化成新的List
```java
原始data:
List userList = new ArrayList<>();
userList.add(new User(1, "张三", 18));
userList.add(new User(2, "李四", 19));
userList.add(new User(3, "王五", 20));
//user的id提取出来
List users = userList;
List idList = users.stream().map(User::getId).collect(Collectors.toList());
//{1, 2, 3}
System.out.println(idList);
```
转化成Map
```java
//1.两个参数的用法
//将userList转化为key为id，value为User对象的map
Map map1 = userList.stream().collect(Collectors.toMap(User::getId, p -> p));
Map map2 = userList.stream().collect(Collectors.toMap(User::getId, p -> p));
//结果
{
1: User(1, "张三", 18)
2: User(2, "李四", 19)
3: User(3, "王五", 20)
}
//2.三个参数的用法
Map map3 = userList.stream().collect(Collectors.toMap(User::getAge, User::getName, (a, b) -> b));
//结果
{
19: "李四"
20: "王五"
}
//Collectors.groupingBy()
//当你想获取key是age的map，又不想覆盖掉重复项数据
Map> map4 = userList.stream().collect(Collectors.groupingBy(User::getAge));
System.out.println(map4);
//结果
{
18: [User(1, "张三", 18), User(3, "王五", 19)]
19: [User(2, "李四", 20)]
}
```
###### ②统计(count/averaging)
`Collectors`提供了一系列用于数据统计的静态方法：
* 计数：`count`
* 平均值：`averagingInt`、`averagingLong`、`averagingDouble`
* 最值：`maxBy`、`minBy`
* 求和：`summingInt`、`summingLong`、`summingDouble`
* 统计以上所有：`summarizingInt`、`summarizingLong`、`summarizingDouble`
```java
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(1, "zhangsan", 18, 4000, "shanghai"));
personList.add(new Person(2, "lisi", 19, 5000, "beijing"));
personList.add(new Person(3, "wanger", 20, 6000, "guangdong"));
personList.add(new Person(4, "mazi", 21, 7000, "jiangxi"));
personList.add(new Person(5, "laoer", 22, 8000, "zhejiang"));
// 求总数
Long count = personList.stream().collect(Collectors.counting());
// 求平均工资
Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
// 求最高工资
Optional max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
// 求工资之和
Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
// 一次性统计所有信息
DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
System.out.println("员工总数：" + count);
System.out.println("员工平均工资：" + average);
System.out.println("员工工资总和：" + sum);
System.out.println("员工工资所有统计：" + collect);
}
//结果
员工总数：5
员工平均工资：6000.0
员工工资总和：30000
员工工资所有统计：DoubleSummaryStatistics{count=5, sum=30000.000000, min=4000.000000, average=6000.000000, max=8000.000000}
```
###### ③分组(partitioningBy/groupingBy)
* 分区：将`stream`按条件分为两个`Map`，比如员工按薪资是否高于 8000 分为两部分。
* 分组：将集合分为多个 Map，比如员工按性别分组。有单级分组和多级分组。
```java
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(1, "zhangsan", 18, 4000, "shanghai", "男"));
personList.add(new Person(2, "lisi", 19, 5000, "beijing", "女"));
personList.add(new Person(3, "wanger", 20, 6000, "guangdong", "男"));
personList.add(new Person(4, "mazi", 21, 7000, "jiangxi", "男"));
personList.add(new Person(5, "laoer", 22, 8000, "zhejiang", "女"));
// 将员工按薪资是否高于8000分组
Map> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
// 将员工按性别分组
Map> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
// 将员工先按性别分组，再按地区分组
Map>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getAddress)));
System.out.println("员工按薪资是否大于5000分组情况：" + part);
System.out.println("员工按性别分组情况：" + group);
System.out.println("员工按性别、地区：" + group2);
}
```
###### ④归约(reducing)
Collectors类提供的reducing方法，相比于stream本身的reduce方法，增加了对自定义归约的支持。
```java
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(1, "zhangsan", 18, 4000, "shanghai", "男"));
personList.add(new Person(2, "lisi", 19, 5000, "beijing", "女"));
personList.add(new Person(3, "wanger", 20, 6000, "guangdong", "男"));
personList.add(new Person(4, "mazi", 21, 7000, "jiangxi", "男"));
personList.add(new Person(5, "laoer", 22, 8000, "zhejiang", "女"));
Integer allAge = personList.stream().map(Person::getAge).collect(Collectors.reducing(Integer::sum)).get();
System.out.println(allAge);
}
//结果
100
```
###### ⑤接合(joining)
`joining`可以将 stream 中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
```java
public static void main(String[] args) {
List personList = new ArrayList();
personList.add(new Person(1, "zhangsan", 18, 4000, "shanghai", "男"));
personList.add(new Person(2, "lisi", 19, 5000, "beijing", "女"));
personList.add(new Person(3, "wanger", 20, 6000, "guangdong", "男"));
personList.add(new Person(4, "mazi", 21, 7000, "jiangxi", "男"));
personList.add(new Person(5, "laoer", 22, 8000, "zhejiang", "女"));
String names = personList.stream().map(t -> t.getName()).collect(Collectors.joining(","));
System.out.println("所有员工的姓名：" + names);
List list = Arrays.asList("A", "B", "C");
String string = list.stream().collect(Collectors.joining("&"));
System.out.println("拼接后的字符串：" + string);
}
//结果
所有员工的姓名：zhangsan,lisi,wanger,mazi,laoer
拼接后的字符串：A&B&C
```
##### 5.3.3 归约(reduce)
归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
```java
//求和，求积
public static void main(String[] args) {
List list = Arrays.asList(1, 2, 3, 4, 7, 9);
Optional sum = list.stream().reduce((x, y) -> x + y);
Optional sum1 = list.stream().reduce(Integer::sum);
Integer sum2 = list.stream().reduce(0, Integer::sum);
Optional product = list.stream().reduce((x, y) -> x * y);
// 最大值方式1
Optional max = list.stream().reduce((x, y) -> x > y ? x : y);
// 最大值方式2
Integer max1 = list.stream().reduce(1, Integer::max);
System.out.println("求和：" + sum.get() + "," + sum1.get() + "," + sum2);
System.out.println("求积：" + product.get());
System.out.println("求和：" + max.get() + "," + max1);
}
//结果
求和：26,26,26
求积：1512
求和：9,9
```
##### 5.3.4 聚合(max/min/count)
Collectors提供了一系列用于数据统计的静态方法：
计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble
```java
//获取最长元素
public static void main(String[] args) {
List list = Arrays.asList("asdas", "asdasdasd", "sdasd", "fdfdf", "qqe");
Optional max = list.stream().max(Comparator.comparing(String::length));
System.out.println("最长的字符串：" + max.get());
}
//结果
最长的字符串：asdasdasd
```
##### 5.3.5 匹配(find/match)
```java
//匹配示例
public static void main(String[] args) {
List strings = Arrays.asList("123", "456", "abc", "sdf", "qwe", "qw2", "qwe");
//anyMatch 判断集合中是否至少存在一个元素满足条件
boolean a = strings.stream().anyMatch("123"::equals);
System.out.println(a);
//allMatch 判断集合中是否所有元素都满足条件
boolean b = strings.stream().allMatch("123"::equals);
System.out.println(b);
//noneMatch 判断集合中是否所有元素都不满足条件
boolean c = strings.stream().noneMatch("123"::equals);
System.out.println(c);
//findAny 返回当前流中任意元素
Optional any = strings.stream().findAny();
any.ifPresent(System.out::println);
//findFirst 返回当前流中第一个元素
Optional first = strings.stream().findFirst();
first.ifPresent(System.out::println);
}
//结果
true
false
false
123
123
```
### 6. Steam的总结
**Stream**极大的简化了开发的代码量，Stream API提供了多个方法对集合进行映射、过滤、排序等操作，其操作不会对原始的集合产生影响，这边列举了部分例子供参考，仅作为学习笔记使用，欢迎批评指正，要是感兴趣可以关注微信订阅号 **=程序own=**