一文带你彻底掌握Java Stream流
最近在看同事们的代码，发现很多地方都在用stream流进行集合的相关的操作，看了之后感觉确实很简洁、优雅，今天带着大家一起学习一下stream流的相关操作。
1.什么是stream流
Java 8 新增的 Stream 是为了解放程序员操作集合（Collection）时的生产力，之所以能解放，很大一部分原因可以归功于同时出现的 Lambda 表达式——极大的提高了编程效率和程序可读性。
从“Stream”这个单词上来看，它似乎和 java.io 包下的 InputStream 和 OutputStream 有些关系。实际上呢，没毛关系。Java 8 新增的 Stream 是为了解放程序员操作集合（Collection）时的生产力，之所以能解放，很大一部分原因可以归功于同时出现的 Lambda 表达式——极大的提高了编程效率和程序可读性。
同时stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。在Stream中的操作每一次都会产生新的流，内部不会像普通集合操作一样立刻获取值，而是惰性 取值，只有等到用户真正需要结果的时候才会执行。并且对于现在调用的方法，本身都是一种高层次构件，与线程模型无关。因此在并行使用中，开发者们无需再去操心线程和锁了。Stream内部都已经做好了。
2.流操作详解
2.1 流创建
生成流的方式主要有五种
1.Stream创建
//创建一个顺序流
Stream<Integer> stream1 = Stream.of(1,2,3,4,5);
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();
stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。
以筛选集合中的奇数为例，来看看两者之间处理方式有何不同
如果流中的数据量足够大，并行流可以加快处速度。
除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：
Optional<Integer> findFirst = list.stream().parallel().filter(x->x>100).findFirst();
2.Collection集合创建（实际使用中最常用的一种）
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
Stream<Integer> listStream = list.stream();
3.Array数组创建
int[] intArr = {1, 2, 3, 4, 5};
IntStream arrayStream = Arrays.stream(intArr);
值得我们注意的是通过Arrays.stream方法生成流，并且该方法生成的流是数值流【即IntStream】而不是 Stream
使用数值流可以避免计算过程中拆箱装箱，提高性能。
Stream API提供了mapToInt、mapToDouble、mapToLong三种方式将对象流,可以将Stream转换成对应的数值流，同时提供了boxed方法将数值流转换为对象流
4.文件创建
try {
Stream<String> fileStream = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());
} catch (IOException e) {
e.printStackTrace();
}
通过Files.line方法得到一个流，并且得到的每个流是给定文件中的一行
5.函数创建
函数创建也有两种方式：
iterator
Stream<Integer> iterateStream = Stream.iterate(0, n -> n + 2).limit(5);
iterate方法接受两个参数，第一个为初始化值，第二个为进行的函数操作，因为iterator生成的流为无限流，通过limit方法对流进行了截断。
上面这段代码的含义则是：n从0开始，每次执行+2操作，并通过limit限制操作的次数，即生成5个偶数
generator
Stream<Double> generateStream = Stream.generate(Math::random).limit(5);
generate方法接受一个参数，方法参数类型为Supplier ，由它为流提供值。generate生成的流也是无限流，因此通过limit对流进行了截断
2.2 操作流
Stream 类提供了很多有用的操作流的方法，根据流的操作类型，主要分为：中间操作和终端操作
- 中间操作：会返回一个流，通过这种方式可以将多个中间操作连接起来，形成一个调用链，从而转换为另外 一个流。除非调用链后存在一个终端操作，否则中间操作对流不会进行任何结果处理。
- 终端操作：会返回一个具体的结果，如boolean、list、integer等
举个简单的例子来理解这两种操作类型
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
long count = list.stream().distinct().count();
System.out.println(count);
distinct() 方法是一个中间操作（去重），它会返回一个新的流（没有共同元素）。
Stream<T> distinct();
而count则是一个终端操作，因为它返回的是一个具体的结果
long count();
中间操作不会立即执行，只有等到终端操作的时候，流才开始真正地遍历，用于映射、过滤等。通俗点说，就是一次遍历执行多个操作，性能就大大提高了。
通常对于Stream的中间操作，可以视为是源的查询，并且是懒惰式的设计，对于源数据进行的计算只有在需要时才会被执行，与数据库中视图的原理相似；
Stream流的强大之处便是在于提供了丰富的中间操作，相比集合或数组这类容器，极大的简化源数据的计算复杂度
一个流可以跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用
这类操作都是惰性化的，仅仅调用到这类方法，并没有真正开始流的遍历，真正的遍历需等到终端操作时，常见的中间操作有下面即将介绍的 filter、map 等
| 流方法 | 含义 | 示例 |
|---|---|---|
| filter | 用于通过设置的条件过滤出元素 | List strings = Arrays.asList(“abc”, “”, “bc”, “efg”, “abcd”,“”, “jkl”); List filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList()); |
| map | 接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”） | List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”); List mapped = strings.stream().map(str->str+“-IT”).collect(Collectors.toList()); |
| distinct | 返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流 | List numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println); |
| sorted | 返回排序后的流 | List strings1 = Arrays.asList(“abc”, “abd”, “aba”, “efg”, “abcd”,“jkl”, “jkl”); List sorted1 = strings1.stream().sorted().collect(Collectors.toList()); |
| limit | 会返回一个不超过给定长度的流 | List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”); List limited = strings.stream().limit(3).collect(Collectors.toList()); |
| skip | 返回一个扔掉了前n个元素的流 | List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”); List skiped = strings.stream().skip(3).collect(Collectors.toList()); |
| flatMap | 使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流 | List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”); Stream flatMap = strings.stream().flatMap(Java8StreamTest::getCharacterByString); |
| peek | 对元素进行遍历处理 | List strings = Arrays.asList(“abc”, “abc”, “bc”, “efg”, “abcd”,“jkl”, “jkl”); strings .stream().peek(str-> str + “a”).forEach(System.out::println); |
在进行具体的操作之前，大家可以mock一些数据进行测试
private static List<User> getUserList() {
List<User> userList = new ArrayList<>();
userList.add(new User(1,"张三",18,"上海"));
userList.add(new User(2,"王五",16,"上海"));
userList.add(new User(3,"李四",20,"上海"));
userList.add(new User(4,"张雷",22,"北京"));
userList.add(new User(5,"张超",15,"深圳"));
userList.add(new User(6,"李雷",24,"北京"));
userList.add(new User(7,"王爷",21,"上海"));
userList.add(new User(8,"张三丰",18,"广州"));
userList.add(new User(9,"赵六",16,"广州"));
userList.add(new User(10,"赵无极",26,"深圳"));
return userList;
}
public class User {//自己写构造函数和get set方法吧
Integer id;
String name;
int age;
String address;
}
filter：过滤、筛选
用于通过设置的条件过滤出元素，该方法会接收一个返回boolean的函数作为参数，终返回一个包括所有符合条件元素的流。
List<User> userList=getUserList();//getUserList方法在文章上面
//获取年龄大于等于20的用户
List<User> res=userList.stream().filter(user -> user.getAge()>=20).collect(Collectors.toList());
System.out.println(res);
我们看一下filter是如何实现元素的过滤的
此处可以看到filter方法接收了Predicate函数式接口。
Predicate函数式接口作用就是对某种数据类型的数据进行判断，结果返回一个boolean值
上面的代码逻辑大致如下：
首先判断predicate是否为null，如果为null，则抛出NullPointerException;
构建Stream，重写opWrapsink方法。
- 参数flags表示下一个sink的标识位，用于优化
- 参数sink将sink构造成单链
此时流已经构建好，但是因为begin（）先执行，此时是无法确定流中后续会存在多少元素的，所以传递-1，代表无法确定。最后调用Pridicate中的test，进行条件判断，将符合条件数据放入流中。
distinct：数据去重
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
List<Integer> res=integers.stream().distinct().collect(Collectors.toList());
System.out.println(res);
我们上面实现了对整型数组中的元素去重，其本质是基于LinkedHashSet对流中数据进行去重，并终返回一个新的流。
如果我们想通过对象中的某些属性作为判断重复的标准，那么我们仅仅通过distinct方法则难以实现，因为它是基于hashCode（）和equals（）工作的。
不过我们可以通过其它方法来实现：distinctByKey
public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
Map<Object,Boolean> seen = new ConcurrentHashMap<>();
return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}
List<User> res = userList.stream().filter(distinctByKey(b -> b.getAge())).collect(Collectors.toList());
System.out.println(res);
上面实现了通过年龄去重，如果是多个字段则可以按照下面这种构造实现
List<User> res = userList.stream()
.filter(distinctByKey(b -> b.getAge()))
.filter(distinctByKey(b -> b.getAddress()))
.collect(Collectors.toList());
上面这段代码则实现了通过年龄和地址两个字段进行去重
limit：实现数据的截取
该方法会返回一个不超过给定长度的流
List<User> res = userList.stream().limit(3).collect(Collectors.toList());
获取数组的前3个数据
对于limit方法，它会接收截取的长度，如果该值小于0，则抛出异常，否则会继续向下调用 SliceOps.makeRef()。
该方法中this代表当前流，skip代表需要跳过元素，比方说本来应该有4个元素，当跳过元素 值为2，会跳过前面两个元素，获取后面两个。maxSize代表要截取的长度
在makeRef方法中的unorderedSkipLimitSpliterator()中接收了四个参数Spliterator，skip(跳过个数)、limit(截取 个数)、sizeIfKnown(已知流大小)。
如果跳过个数小于已知流大小，则判断跳过个数是否大于0：
- 如果大于则取截取个数或已知流大小-跳过个数的两者小值
- 否则取已知流大小-跳过个数的结果
最后对集合基于跳过个数和截取个数进行切割。
skip：实现数据的跳过
List<User> res = userList.stream().skip(2).limit(3).collect(Collectors.toList());
System.out.println(res);
表示从集合第3个开始截取，取3个元素
List<User> res = userList.stream().limit(5).skip(2).collect(Collectors.toList());
System.out.println(res);
表示截取前五个元素，然后跳过取出后的前两个元素，从第三个元素开始取
同样，我们看看源码的实现：
在skip方法中接收的n代表的是要跳过的元素个数，如果n小于0，抛出非法参数异常，如果n等于0，则返回当前 流。如果n小于0，才会调用makeRef()。同时指定limit参数为-1.
此时可以发现limit和skip都会进入到该方法中，在确定limit值时，如果limit<0,则获取已知集合大小长度-跳过的长度。最终进行数据切割。
map：实现元素的映射
List<String> res = userList.stream().map(User::getName).collect(Collectors.toList());
System.out.println(res);
源码解析：
核心则是其内部对Function函数式接口中的apply方法进行实现，接收一个对象，返回另外一个对象，并把这个内容存入当前 流中，然后返回
foreach/find/match：遍历/匹配
Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。
List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
list.stream().filter(x -> x > 6).forEach(System.out::println);
// 匹配第一个
Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
System.out.println("匹配第一个值：" + findFirst.get());
// 匹配任意（适用于并行流）
Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
System.out.println("匹配任意一个值：" + findAny.get());
// 是否包含符合特定条件的元素
boolean anyMatch = list.stream().anyMatch(x -> x > 6);
System.out.println("是否存在大于6的值：" + anyMatch);
同样我们简单的分析一下上面实现的原理
- anyMatch
通过上面的操作可以看出当流中只要有一个符合条件的元素，则会立刻中止后续的操作，立即返回一个布尔值，无需遍历整个流
内部实现会调用makeRef(),其接收一个Predicate函数式接口，并接收一个枚举值，该值代表当前操作执行的是 ANY。
如果predicate.test()抽象方法执行返回值==MatchKind中any的stopOnPredicateMatches，则将stop中断置为true，value 也为true，然后进行返回，无需进行后续的流操作。
reduce：累积求和
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
Integer res = integers.stream().reduce(0,(int1,int2)->int1+int2);
System.out.println(res);
在上述代码中，在reduce里的第一个参数声明为初始值，第二个参数接收一个lambda表达式，代表当前流中的两 个元素，它会反复相加每一个元素，直到流被归约成一个终结果
Integer reduce = integers.stream().reduce(0,Integer::sum);
当然优化成上述所示也可以。
reduce还有一个不带初始值参数的重载方法，但是要对返回结果进行判断，因为如果流中没有任何元素的话，可能就没有结果了。具体方法如下所示
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
Optional<Integer> reduce = integers.stream().reduce(Integer::sum);
if(reduce.isPresent()){
System.out.println(reduce);
}else {
System.out.println("数据有误");
}
在上述方法中，对于流中元素的操作，当执行第一个元素，会进入begin方法，将初始化的值给到state，state就是最后的返回结果。
执行accept方法，对state和第一个元素根据传入的操作，对两个值进行计算。并把终计算结果赋给state。 当执行到流中第二个元素，直接执行accept方法，对state和第二个元素对两个值进行计算，并把终计算结果赋 给state。后续依次类推。
获取流中元素的最大值、最小值
最大值
/**
* 获取集合中的最大值
*/
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
//方法一
Optional<Integer> max1 = integers.stream().reduce(Integer::max);
if (max1.isPresent()) {
System.out.println(max1);
}
//方法二
Optional<Integer> max2 = integers.stream().max(Integer::compareTo);
if (max2.isPresent()) {
System.out.println(max2);
}
/**
* 获取实体列表中的年龄的最大值
*/
Optional<Integer> max11 = userList.stream().map(user -> user.getAge()).reduce(Integer::max);
if (max11.isPresent()) {
System.out.println(max11);
}
Optional<String> max21 = userList.stream().map(user -> user.getAddress()).max(String::compareTo);
if (max11.isPresent()) {
System.out.println(max21);
}
最小值
/**
* 获取集合中的最小值
*/
//方法一
Optional<Integer> min1 = integers.stream().reduce(Integer::min);
if(min1.isPresent()){
System.out.println(min1);
}
//方法二
Optional<Integer> min2 = integers.stream().min(Integer::compareTo);
if(min2.isPresent()){
System.out.println(min2);
}
Collectors：收集器
通过使用收集器，可以让代码更加方便的进行简化与重用。其内部主要核心是通过Collectors完成更加复杂的计算 转换，从而获取到终结果。并且Collectors内部提供了非常多的常用静态方法，直接拿来就可以了。比方说： toList。
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class Demo02 {
public static void main(String[] args) {
List<User> userList = getUserList();
/**
* 统计集合数
*/
//方法1：counting
Long collect = userList.stream().collect(Collectors.counting());
System.out.println(collect);
//方法2：count()
collect = userList.stream().count();
System.out.println(collect);
/**
* 求最大值
*/
//1.通过maxBy求最大值
Optional<User> collect1 = userList.stream().collect(Collectors.maxBy(Comparator.comparing(User::getAge)));
if (collect1.isPresent()) {
System.out.println("通过maxBy求最大值：" + collect1);
}
//2.通过max求最大值
collect1 = userList.stream().max(Comparator.comparing(User::getAge));
if (collect1.isPresent()) {
System.out.println("通过max求最大值：" + collect1);
}
/**
* 求最小值
*/
//通过minBy求最小值
Optional<User> collect2 = userList.stream().collect(Collectors.minBy(Comparator.comparing(User::getAge)));
if (collect2.isPresent()) {
System.out.println("通过minBy求最小值：" + collect2);
}
//通过min求最小值
Optional<User> min = userList.stream().min(Comparator.comparing(User::getAge));
if (min.isPresent()) {
System.out.println("通过min求最小值：" + min);
}
/**
* 通过summingInt()进行数据汇总
*/
Integer collect3 = userList.stream().collect(Collectors.summingInt(User::getAge));
System.out.println("通过summingInt()进行数据汇总：" + collect3);
/**
* 通过averagingInt()进行平均值获取
*/
Double collect4 = userList.stream().collect(Collectors.averagingInt(User::getAge));
System.out.println("通过averagingInt()进行平均值获取：" + collect4);
/**
* 通过joining()进行数据拼接
*/
String collect5 = userList.stream().map(User::getName).collect(Collectors.joining());
System.out.println("通过joining()进行数据拼接" + collect5);
/**
* 复杂结果的返回
*/
IntSummaryStatistics collect6 = userList.stream().collect(Collectors.summarizingInt(User::getAge));
double average = collect6.getAverage();
long sum = collect6.getSum();
long count1 = collect6.getCount();
int max1 = collect6.getMax();
int min1 = collect6.getMin();
System.out.println("复杂结果的返回：average：" + average + "，sum：" + sum + "，count1：" + count1 + ",max1：" + max1 + ",min1：" + min1);
}
private static List<User> getUserList() {
List<User> userList = new ArrayList<>();
userList.add(new User(1, "张三", 18, "上海"));
userList.add(new User(2, "王五", 16, "上海"));
userList.add(new User(3, "李四", 20, "上海"));
userList.add(new User(4, "张雷", 22, "北京"));
userList.add(new User(5, "张超", 15, "深圳"));
userList.add(new User(6, "李雷", 24, "北京"));
userList.add(new User(7, "王爷", 21, "上海"));
userList.add(new User(8, "张三丰", 18, "广州"));
userList.add(new User(9, "赵六", 16, "广州"));
userList.add(new User(10, "赵无极", 26, "深圳"));
return userList;
}
}
分组
在数据库操作中，经常会通过group by对查询结果进行分组。同时在日常开发中，也经常会涉及到这一类操作， 如通过性别、地址等对用户集合进行分组。
如果通过普通编码的方式需要编写大量代码且可读性不好，对于这个问题的解决，java8也提供了简化书写的方式。通过 Collectors。groupingBy()即可。
Map<String, List<User>> collect = userList.stream().collect(Collectors.groupingBy(User::getAddress));
Set<String>keys=collect.keySet();
for (String key:keys){
System.out.println(key+"->"+collect.get(key));
}
多级分组
刚才已经使用groupingBy()完成了分组操作，但是只是通过单一的属性值进行分组，那现在如果需求发生改变，还要按照年龄进行分组的话，我们同样也可以利用groupingBy()方法进行实现，对于groupingBy()它提供了两个参数的重载方法，用于完成这种需求。
这个重载方法在接收普通函数之外，还会再接收一个Collector类型的参数，其会在内层分组(第二个参数)结果，传 递给外层分组(第一个参数)作为其继续分组的依据。
Map<String, Map<Integer, List<User>>> collect1 = userList.stream().collect(Collectors.groupingBy(User::getAddress, Collectors.groupingBy(User::getAge)));
System.out.println(collect1);
看到此处，想必你对stream的功能和用法已经掌握了，自己可以尝试着去优化一下自己之前写的代码，让你的代码风格更加优雅。
相关文章推荐：
- 《Optional的使用详解》