JDK8中的Stream怎么用

Java 8引入了Stream API，它提供了一种高效且易于使用的方式来处理集合数据。Stream API允许开发者以声明式的方式处理数据，并且可以利用多核架构进行并行处理。本文将详细介绍Stream的基本概念、常用操作以及如何使用Stream来处理集合数据。

1. 什么是Stream？

Stream是Java 8中引入的一个新抽象，它代表一个元素序列，并支持对这些元素进行各种操作。Stream本身并不存储数据，而是从数据源（如集合、数组、I/O通道等）获取数据，并通过一系列操作（如过滤、映射、排序等）来处理这些数据。

Stream的特点包括：

• 无存储：Stream不是数据结构，它只是从数据源获取数据。
• 函数式编程：Stream的操作是函数式的，支持链式调用。
• 惰性求值：Stream的操作是惰性的，只有在终端操作时才会执行。
• 可并行化：Stream可以很容易地并行化处理数据。

2. 创建Stream

在Java 8中，可以通过多种方式创建Stream。

2.1 从集合创建Stream

最常用的方式是从集合（如List、Set等）创建Stream：

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

2.2 从数组创建Stream

可以通过Arrays.stream()方法从数组创建Stream：

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

2.3 使用Stream.of()创建Stream

Stream.of()方法可以用于创建包含指定元素的Stream：

Stream<String> stream = Stream.of("a", "b", "c");

2.4 使用Stream.generate()创建无限Stream

Stream.generate()方法可以用于生成一个无限流，通常需要与limit()方法结合使用：

Stream<String> stream = Stream.generate(() -> "element").limit(10);

2.5 使用Stream.iterate()创建无限Stream

Stream.iterate()方法可以用于生成一个无限流，通常需要与limit()方法结合使用：

Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(10);

3. Stream的中间操作

Stream的中间操作是指那些返回Stream的操作，它们可以链式调用。常见的中间操作包括filter、map、sorted等。

3.1 filter

filter操作用于过滤元素，只保留满足条件的元素：

List<String> list = Arrays.asList("a", "b", "c", "d");
List<String> result = list.stream()
                          .filter(s -> s.startsWith("a"))
                          .collect(Collectors.toList());
// result: ["a"]

3.2 map

map操作用于将元素映射为另一种形式：

List<String> list = Arrays.asList("a", "b", "c");
List<String> result = list.stream()
                          .map(String::toUpperCase)
                          .collect(Collectors.toList());
// result: ["A", "B", "C"]

3.3 sorted

sorted操作用于对元素进行排序：

List<String> list = Arrays.asList("c", "a", "b");
List<String> result = list.stream()
                          .sorted()
                          .collect(Collectors.toList());
// result: ["a", "b", "c"]

3.4 distinct

distinct操作用于去除重复元素：

List<String> list = Arrays.asList("a", "b", "a", "c");
List<String> result = list.stream()
                          .distinct()
                          .collect(Collectors.toList());
// result: ["a", "b", "c"]

3.5 limit

limit操作用于限制流中元素的数量：

List<String> list = Arrays.asList("a", "b", "c", "d");
List<String> result = list.stream()
                          .limit(2)
                          .collect(Collectors.toList());
// result: ["a", "b"]

3.6 skip

skip操作用于跳过流中的前N个元素：

List<String> list = Arrays.asList("a", "b", "c", "d");
List<String> result = list.stream()
                          .skip(2)
                          .collect(Collectors.toList());
// result: ["c", "d"]

4. Stream的终端操作

Stream的终端操作是指那些返回非Stream结果的操作，它们会触发流的处理。常见的终端操作包括forEach、collect、reduce等。

4.1 forEach

forEach操作用于对每个元素执行操作：

List<String> list = Arrays.asList("a", "b", "c");
list.stream().forEach(System.out::println);
// 输出:
// a
// b
// c

4.2 collect

collect操作用于将流中的元素收集到一个集合中：

List<String> list = Arrays.asList("a", "b", "c");
List<String> result = list.stream()
                          .collect(Collectors.toList());
// result: ["a", "b", "c"]

4.3 reduce

reduce操作用于将流中的元素归约为一个值：

List<Integer> list = Arrays.asList(1, 2, 3);
Optional<Integer> result = list.stream()
                               .reduce(Integer::sum);
// result: 6

4.4 count

count操作用于统计流中元素的数量：

List<String> list = Arrays.asList("a", "b", "c");
long count = list.stream().count();
// count: 3

4.5 anyMatch、allMatch、noneMatch

这些操作用于检查流中的元素是否满足某个条件：

List<String> list = Arrays.asList("a", "b", "c");
boolean anyMatch = list.stream().anyMatch(s -> s.startsWith("a"));
boolean allMatch = list.stream().allMatch(s -> s.startsWith("a"));
boolean noneMatch = list.stream().noneMatch(s -> s.startsWith("d"));
// anyMatch: true
// allMatch: false
// noneMatch: true

5. 并行Stream

Stream API支持并行处理，可以通过parallelStream()方法创建并行流：

List<String> list = Arrays.asList("a", "b", "c");
List<String> result = list.parallelStream()
                          .map(String::toUpperCase)
                          .collect(Collectors.toList());
// result: ["A", "B", "C"]

并行流可以充分利用多核处理器的优势，但需要注意线程安全问题。

6. 总结

Stream API是Java 8中引入的一个强大工具，它提供了一种高效且易于使用的方式来处理集合数据。通过Stream，开发者可以以声明式的方式处理数据，并且可以利用多核架构进行并行处理。本文介绍了Stream的基本概念、创建方式、常用操作以及如何使用并行流。希望本文能帮助你更好地理解和使用Stream API。