Java Stream 流使用

Java Stream 流使用

1.0 Stream 概述

​ Java Stream 是在 Java 8 中引入的一种用于处理集合数据的新 API，它提供了一种更为简便、高效、灵活的方式来对集合中的数据进行操作。Stream 的出现使得 Java 集合框架更加完善，可以大大减少对集合中数据的遍历和操作代码的编写，而且支持并行处理，使得处理大数据集合时性能更佳

2.0 创建 Stream

​ Java 中的 Stream 可以由各种数据源创建，如集合、数组、I/O 通道等

2.1 从集合中创建 Stream

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

2.2 从数组中创建 Stream 流

String[] array = new String[]{"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

2.3 从文件中创建 Stream 流

Path path = Paths.get("D:/demo.txt");
Stream<String> stream = Files.lines(path); //stream 流里面装的是文件内容

3.0 Stream 常用方法

​ Stream 对象可以看作是一个高级版本的迭代器，它提供的方法可以非常方便地对集合数据进行各种操作和转换

3.0.1 Stream 的 终止方法和非终止方法

​ 非终止方法是指对 Stream 对象进行的处理，返回的仍然是 Stream 对象，可以通过链式调用方式进行多次操作。这些方法通常用于对数据进行筛选、映射、排序等预处理操作

​ 终止操作则是最后一步操作，通常会将 Stream 对象处理成最终结果，返回一个非 Stream 的值或对象。只有执行了终止操作，Stream 对象才能真正开始处理数据

3.1.1 filter 过滤

​ filter 方法用于过滤集合中的元素，接受一个 Predicate 参数（函数式接口），该参数用于指定过滤条件，满足条件的元素才会被保留

List<String> list = Arrays.asList("a", "b", "c", "d");
Stream<String> stream = list.stream().filter("a"::equals);//与 a 相等的元素才会被保留

3.1.2 collect 收集 （终止方法）

​ collect 方法将流中的元素收集到一个新的容器中并返回，接收一个 Collectors 参数（收集器的实现，实现各种有用的缩减操作，例如将元素累积到集合中，根据各种标准汇总元素等）

List<Student> students = new ArrayList<>();
Collections.addAll(students,
        new Student(1L,"张三",19,60D),
        new Student(2L,"李四",20,69D),
        new Student(1L,"王五",19,90D)
);
Stream<Student> stream = students.stream()
        .filter(student -> 19 <= student.getAge());//过滤掉大于 19 岁的学生
//将流中的元素收集到一个新的 List 容器中并返回
List<Student> list = stream.collect(Collectors.toList());
//将流中的元素收集到一个新的 Set 容器中并返回
Set<Student> set = stream.collect(Collectors.toSet());
//将流中的元素收集到一个新的 Map 容器中并返回,key 为 id,value 为 student 对象
//最后一个参数意思是如果有 key 相同取第一个 student，不加此参数遇到有多个 key 相同会报出异常
Map<Long, Student> map = stream.collect(Collectors.toMap(Student::getId, Function.identity(), (student1, student2) -> student1));
//通过对 stream 进行分组操作，将相同 ID 的 Student 对象放在同一个列表中，得到的一个分组结果,key 为 id
Map<Long, List<Student>> idMap = stream.collect(Collectors.groupingBy(Student::getId));
//通过对 stream 进行分组操作，将相同 ID 的 Student 对象放在同一个列表中，并计算每个分组内的分数之和，得到的一个分组结果。
Map<Long, Double> scoreMap = stream.collect(Collectors.groupingBy(Student::getId, Collectors.summingDouble(Student::getScore)));
//通过 stream 进行分区操作，将大于等于 60 分的学生存入 map 中 key 为 true，而低于 60 存入 map 中 key 为 false
Map<Boolean, List<Student>> passingFailing = students.stream()
        .collect(Collectors.partitioningBy(student -> student.getScore() >= 60));
//上述代码 stream 使用过终止方法后就不能再次使用

3.1.3 map 提取

​ map 方法用于将集合中的元素按照指定规则进行映射转换，接受一个 Function 参数（函数式接口），该参数用于指定映射规则

List<Student> students = new ArrayList<>();
Collections.addAll(students,
        new Student(1L,"张三",19,59D),
        new Student(2L,"李四",20,69D),
        new Student(1L,"王五",19,90D)
);
//通过 stream 进行提取操作，将 Student 对象中的 name 属性提取到一个新的集合中
List<String> names = students.stream().map(Student::getName).collect(Collectors.toList());

3.1.4 distinct 去重

​ distinct 方法用于将集合中的元素，本质会使用 equals 方法判断两个元素是否相等

List<Integer> list = Arrays.asList(2,4,6,8,10,2,4,6);
//使用 distinct() 方法进行去重操作 [2, 4, 6, 8, 10]
List<Integer> intList = list.stream().distinct().collect(Collectors.toList());

3.14 max 最大值 min最小值 （终止方法）

​ max 获取集合中的最大值，min 获取集合中的最小值

List<Integer> list = Arrays.asList(2, 4, 6, 8, 10, 2, 4, 6);
//通过 max 获取最大值
Integer max = list.stream().max(Integer::compareTo).orElse(0);
//通过 min 获取最小值
Integer min = list.stream().min(Integer::compareTo).orElse(0);

3.15 reduce 聚合 （终止方法）

​ reduce 方法用于对集合中的元素进行聚合操作，例如求和、求最大值等。它接受一个 BinaryOperator 参数（函数式接口），该参数用于指定聚合规则

List<Integer> list = Arrays.asList(2, 4, 6, 8, 10, 2, 4, 6);
//通过 reduce 进行求和
Integer sum = list.stream().reduce(Integer::sum).orElse(0);
//通过 reduce 获取最大值
Integer max = list.stream().reduce((x, y) -> x > y ? x : y).orElse(0);

3.16 count 统计 （终止方法）

​ count 方法可以统计 Stream 中元素的数量

List<Integer> list = Arrays.asList(2, 4, 6, 8, 10, 2, 4, 6);
long count = list.stream().count();

3.17 sorted 排序

​ sorted 方法用于对集合中的元素进行排序，接受一个 Comparator （函数式接口）参数，该参数用于指定排序规则

List<Integer> list = Arrays.asList(2, 4, 6, 8, 10, 2, 4, 6);
//从大到小排序
List<Integer> collect = list.stream().sorted((a, b) -> b - a).collect(Collectors.toList());