1.Stream API 介绍
Java8 版本引入的重要特性之一, 对于集合（例如 List、Map、Set 等）进行处理和操作的高级抽象.Stream API 提供了一种更为简洁高效的的方式来处理集合数据, 可读性较高, 特别在数据的过滤、转换、聚合时的操作很简单方便快捷.
1.1 特点与优势
- 函数式风格: Stream API使用函数式接口和Lambda表达式, 让代码更具表达力和简洁性.
- 惰性求值: Stream操作通常是惰性求值的, 这意味着在终端操作之前, 中间操作不会立即执行, 从而提高了效率.
- 并行处理: 通过Stream API可以方便地实现并行处理, 从而充分利用多核处理器的优势, 加速处理大量数据的过程.
下面根据一些实际应用场景来分析
1.2 两大类型
- 中间操作(Intermediate Operations):中间操作是指在Stream上执行的操作, 它们返回一个新的Stream, 允许你链式地进行多个中间操作.
- 终端操作(Terminal Operations):对Stream进行最终处理的操作, 当调用终端操作时, Stream会开始执行中间操作, 并生成最终的结果或副作用.终端操作是Stream的"触发器", 一旦调用终端操作, Stream就不能再被使用, 也不能再进行中间操作.
2.Stream API 中间操作
2.1 filter(条件)
用于根据指定条件过滤元素.它接收一个条件作为参数, 只保留满足条件的元素, 并生成一个新的Stream.
示例:
存在一个姓名的集合，现在要过滤出来名字中带【大】的人员.
public static void main(String[] args) {
List tempList = Arrays.asList("刘一手", "杜子腾", "林大蛋", "Ekko");
List resList = tempList.stream()
.filter(s -> s.contains("大"))
.collect(Collectors.toList());
System.out.println(resList.toString());
}
输出:
[林大蛋]
这段Java代码展示了如何使用Java Stream API对一个字符串列表进行处理，并筛选出包含字符"大"的字符串，然后将筛选后的结果收集到一个新的列表中，最后输出结果。
让我们逐步解释这段代码：
首先我们创建了一个包含四个字符串的集合，后使用 Stream API 对 tempList 进行处理。
首先，通过调用stream()方法，将tempList转换为一个Stream。
接着，使用filter中间操作筛选出包含字符"大"的字符串。
这里的filter方法接收一个Lambda表达式作为参数，Lambda 表达式s -> s.contains("大")用于判断字符串是否包含字符"大"。
只有满足条件的字符串会被保留在Stream中。
collect(Collectors.toList())这部分是终端操作，它将Stream中的元素收集到一个新的列表中。在这里，我们使用Collectors.toList()方法来将Stream中的筛选结果收集到一个新的List中，赋值给resList。
2.2 map(函数)
用于对每个元素执行映射操作, 将元素转换成另一种类型.它接收一个Function（映射函数）作为参数, 对每个元素应用该映射函数, 并生成一个新的Stream.
示例:
存在一个姓名的集合，现在要给所有名字加上姓名的前缀.
public static void main(String[] args) {
List tempList = Arrays.asList("刘一手", "杜子腾", "林大蛋", "Ekko");
List resList = tempList.stream()
.map(s -> "姓名: " + s)
.collect(Collectors.toList());
System.out.println(resList.toString());
}
输出:
[姓名: 刘一手, 姓名: 杜子腾, 姓名: 林大蛋, 姓名: Ekko]
这段代码的意思是创建一个姓名集合，通过stream()方法把集合转换为 Stream 流,通过 map() 方法给每个集合中的值拼接字符串后,使用collect()方法把这些元素归集到一个新的 List 集合并赋值给 resList.
这里的
.map(s -> "姓名: " + s)是简写,详细的更容易理解的写法如下:.map(s -> {
return "姓名: " + s;
})
2.3 flatMap(函数)
类似于map操作，但是 flatMap 操作可以将每个元素映射成一个 Stream，然后把所有生成的 Stream 合并成一个新的Stream。
示例:
新建一个静态内部类, 然后聚合类中的集合数据
@Data
static class Personnel {
// 人员姓名
private String name;
// 人员标签
private List tagList;
public Personnel(String name, List tagList) {
this.name = name;
this.tagList = tagList;
}
}
Tips: 就现在想要把 List 中的 tagList 聚合后进行处理, 代码如下:
public static void main(String[] args) {
Personnel personA = new Personnel("张三", Arrays.asList("抽烟", "喝酒", "烫头"));
Personnel personB = new Personnel("李斯", Arrays.asList("编码", "喝酒", "踢足球"));
List personnelList = Arrays.asList(personA, personB);
personnelList.stream()
.flatMap(p -> p.getTagList().stream())
.forEach(s -> System.out.print(s + " "));
}
输出:
抽烟 喝酒 烫头 编码 喝酒 踢足球
2.4 sorted()
用于对Stream中的元素进行排序，默认按照自然顺序进行排序。也可以传入自定义的Comparator来指定排序规则。
示例：
public class SortedTest {
public static void main(String[] args) {
List numList = Arrays.asList(10, 20, 18, 300, 30, 2);
// ① 默认排序
List orderList = numList.stream()
.sorted()
.collect(Collectors.toList());
System.out.printf("① 默认排序: %s%n", orderList);
// ② 自定义排序
List orderDescList = numList.stream()
.sorted((x, y) -> {
return y.compareTo(x);
})
.collect(Collectors.toList());
System.out.printf("② 自定义排序: %s%n", orderDescList);
}
}
输出：
① 默认排序: [2, 10, 18, 20, 30, 300]
② 自定义排序: [300, 30, 20, 18, 10, 2]
关于
return y.compareTo(x);这块的具体意义，可以自行搜索compareTo方法了解下，这里不做单独赘述
2.5 distinct()
用于去除 Stream 中重复的元素，确保最终的 Stream 中每个元素都是唯一的。
示例：
public class DistinctStreamTest {
public static void main(String[] args) {
List numList = Arrays.asList(1,1,1,1,2,3,2,2);
List distinctList = numList.stream()
.distinct()
.collect(Collectors.toList());
System.out.println(distinctList);
}
}
输出：
[1, 2, 3]
这段代码先创建了一个数字集合，接下来使用 stream() 方法转化为 Stream 流
使用 distinct() 方法对流中的元素进行去重，返回一个不包含重复元素的Stream 流
最后使用 collect() 方法对去重后的流转换成一个新的 List 集合。
2.6 limit(long n)
用于限制Stream的大小，返回一个最大包含前n个元素的新Stream。
示例：
public class LimitStreamTest {
public static void main(String[] args) {
List numList = Arrays.asList(1,2,3,4,5,6,7,8);
List limitList = numList.stream()
.limit(4)
.collect(Collectors.toList());
System.out.println(limitList);
}
}
这段代码创建一个包含整数的List集合numList，使用Stream API的limit(4)方法将集合截取为只包含前4个元素的新List集合，并将结果输出到控制台。
输出结果为：[1, 2, 3, 4]
2.7 skip(long n)
用于跳过Stream中的前n个元素，返回一个丢弃了前n个元素后剩余元素的新Stream。
示例：
public class SkipStreamTest {
public static void main(String[] args) {
List numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List skipList = numList.stream()
.skip(numList.size() - 2)
.collect(Collectors.toList());
System.out.println(skipList);
}
}
这段代码创建一个包含整数的List集合numList，使用Stream API的 skip 方法将集合截取跳过前 集合大小-2个元素的新List集合，并将结果输出到控制台。
输出结果为：[7, 8]
2.8 peek(Consumer)
用于对每个元素执行一个操作，同时保持Stream的流。它可以用于调试或记录Stream中的元素。
示例：
public class PeekStreamTest {
public static void main(String[] args) {
List numList = Arrays.asList(5, 6, 7, 8);
List resList = numList.stream()
.peek(System.out::println)
.filter(s -> s == 5)
.peek(s -> System.out.printf("过滤后的:%d%n", s))
.collect(Collectors.toList());
}
}
输出:
5
过滤后的:5
6
7
8
这段代码创建一个包含整数的List集合numList，使用Stream API的 peek 方法记录初始的值，通过中间操作 filter 方法过滤值为 5 的后，再次通过peek 方法来打印并验证我们的表达式后，把过滤后的结果通过 collect 方法生成一个新的 List 集合。
3.终端操作
在Java Stream API中，终端操作（Terminal Operations）是对Stream进行最终处理的操作。当调用终端操作时，Stream会开始执行中间操作，并生成最终的结果或副作用。终端操作是Stream的触发器，一旦调用终端操作，Stream就不能再被使用，也不能再进行中间操作。
以下是一些常见的Stream API终端操作：
3.1 forEach(Consumer)
对Stream中的每个元素执行指定的操作，接收一个Consumer（消费者函数）作为参数。它通常用于对Stream中的元素进行输出或执行某些操作，但不会返回任何结果。
示例: 遍历输出中间操作后的集合
public class ForEachStreamTest {
public static void main(String[] args) {
// 给公司工资普涨 500
List salaryList = Arrays.asList(12000, 20000, 30000, 4000);
salaryList.stream()
.peek(s -> System.out.print("工资普涨前:" + s))
.map(s -> s + 500)
.forEach(s -> {
System.out.println("--工资普涨后:" + s);
});
}
}
以上代码的含义是,创建一个工资集合,通过 stream() 方法转换为 Stream 流,通过中间操作 peek() 方法记录转换前的元素值,后通过 map() 方法给元素进行转换操作,最后通过终端操作 forEach() 方法进行遍历.
输出:
工资普涨前:12000--工资普涨后:12500
工资普涨前:20000--工资普涨后:20500
工资普涨前:30000--工资普涨后:30500
工资普涨前:4000--工资普涨后:4500
3.2 collect(Collector)
用于将Stream中的元素收集到一个容器中，接收一个Collector（收集器）作为参数。它允许你在Stream中执行各种集合操作，例如将元素收集到List、Set、Map等容器中。
示例: 把 User 实体集合转换为 Map 集合,名字作为 key,工资作为 Name
public class CollectStreamTest {
public static void main(String[] args) {
List userList = Arrays.asList(new User("张三", 2000.5),
new User("李斯", 11000.5),
new User("王二", 12000.5),
new User("张六", 32000.5),
new User("赵公子", 1000000.0));
Map userSalaryMap = userList.stream()
.collect(Collectors.toMap(User::getName, User::getSalary));
userSalaryMap.forEach((k, v) -> {
System.out.printf("姓名:%s,工资:%.2f%n", k, v);
});
}
@Data
@AllArgsConstructor
static class User {
private String name;
private Double salary;
}
}
上述代码的含义是创建一个人员集合,通过 stream() 转换为 Stream 流,使用 collect() 方法把元素归集, 利用 Collectors.toMap() 收集器转换为 Map 后,内部接收会遍历每个元素,
Collectors.toMap(User::getName, User::getSalary)是简写,详细的写法如下:Collectors.toMap(s -> s.getName(), s -> s.getSalary())
输出:
姓名:张三,工资:2000.50
姓名:赵公子,工资:1000000.00
姓名:张六,工资:32000.50
姓名:李斯,工资:11000.50
姓名:王二,工资:12000.50
3.3 toArray()
将Stream中的元素转换成一个数组。返回一个包含所有元素的数组，返回的数组类型是根据流元素的类型自动推断的。如果流是空的，将返回一个长度为0的数组。
示例:
public class ToArrayStreamTest {
public static void main(String[] args) {
// 示例整数流
IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
// 使用toArray()将流中的元素收集到一个数组中
int[] intArray = intStream.toArray();
// 输出结果数组
System.out.println(Arrays.toString(intArray));
}
}
输出:
[1, 2, 3, 4, 5]
在这个示例中，我们创建了一个整数流
IntStream，然后使用toArray()方法将流中的所有整数收集到一个数组中，并输出结果数组。
3.4 reduce(BinaryOperator)
Stream 类的 reduce() 方法是用于将流中的元素进行归约操作的方法。接收一个 BinaryOperator（二元运算函数作为参数，用于对两个元素进行操作，并返回一个合并后的结果。它可以将流中的所有元素按照指定的规则进行合并，并返回一个 Optional 对象，因为流可能为空。
示例:
public class ReduceStreamTest {
public static void main(String[] args) {
// 示例整数流
IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
// 使用reduce()将流中的整数相加得到总和
OptionalInt sumOptional = intStream.reduce((a, b) -> a + b);
// 获取结果总和，如果流为空，则给出一个默认值0
int sum = sumOptional.orElse(0);
// 输出结果总和
System.out.println("总和: " + sum);
}
}
输出:
总和: 15
上面的代码中，我们创建了一个整数流
IntStream，然后使用reduce()方法将流中的整数相加得到总和。由于流中有元素，因此reduce()方法返回包含总和的Optional对象。我们使用orElse(0)获取结果总和，防止流为空的情况。最后输出得到的结果总和。
3.5 min(Comparator) / max(Comparator)
Stream 类的 min() 和 max() 方法是用于查找流中的最小值和最大值的终端操作。它们接受一个 Comparator 对象作为参数来确定元素的顺序，并返回一个 Optional 对象，因为流可能为空。
以下是 min() 和 max() 方法的简要解释以及示例代码：
min() 方法：
Optional min(Comparator
