Java 8 Stream API

文章目录

Java 8 Stream API
1. Stream
2. Stream 的创建
3. 常见的 Stream 操作
- 3.1 中间操作
- 3.2 终止操作
4. Stream 的并行操作

Java 8 Stream API

Java 8 引入了 Stream API，使得对集合类（如 List、Set 等）的操作变得更加简洁和直观。Stream API 主要目的是为了简化对集合数据的处理，尤其是支持 函数式编程 风格的操作。
Stream 可以让你使用声明式的方式进行集合操作，而不是传统的命令式方式。

1. Stream

在 Java 8 中，Stream 是一个用于处理数据集合（如 List、Set、Map 等）的工具，它允许你在不修改集合本身的情况下，通过一系列的操作（如过滤、映射、聚合等）来对数据进行处理。
Stream 是一个流式的、单向的数据结构，意味着你一次只能处理流中的一个元素，且每次处理后的流会产生新的流对象，原始流不会发生改变。

2. Stream 的创建

Stream 可以通过以下几种方式创建：

从集合创建 Stream：

List<String> list = Arrays.asList("apple", "banana", "cherry");
Stream<String> stream = list.stream();

从数组创建 Stream：

String[] array = {"apple", "banana", "cherry"};
Stream<String> stream = Arrays.stream(array);

使用 Stream.of() 创建 Stream：

Stream<String> stream = Stream.of("apple", "banana", "cherry");

3. 常见的 Stream 操作

Stream API 提供了两类操作：中间操作和终止操作。

3.1 中间操作

中间操作是惰性操作（Lazy），它们不会立即执行，直到你触发一个终止操作时，才会开始执行整个流的计算。常见的中间操作包括：

filter：用于过滤流中的元素，返回符合条件的元素。

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
List<String> filteredList = list.stream()
                                .filter(s -> s.startsWith("a"))
                                .collect(Collectors.toList());
System.out.println(filteredList); // 输出: [apple]

map：用于将流中的元素通过函数转换成另一个类型的元素（通常是映射操作）。

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> upperCaseList = list.stream()
                                 .map(String::toUpperCase)
                                 .collect(Collectors.toList());
System.out.println(upperCaseList); // 输出: [APPLE, BANANA, CHERRY]

distinct：去除重复的元素。

List<String> list = Arrays.asList("apple", "banana", "apple", "cherry");
List<String> distinctList = list.stream()
                                .distinct()
                                .collect(Collectors.toList());
System.out.println(distinctList); // 输出: [apple, banana, cherry]

sorted：对流中的元素进行排序。

List<String> list = Arrays.asList("banana", "apple", "cherry");
List<String> sortedList = list.stream()
                              .sorted()
                              .collect(Collectors.toList());
System.out.println(sortedList); // 输出: [apple, banana, cherry]

flatMap：将流中的每个元素映射成多个元素，然后再将所有这些元素合并成一个流。

List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("apple", "banana"),
    Arrays.asList("cherry", "date"));

List<String> flatMappedList = listOfLists.stream()
                                         .flatMap(List::stream)
                                         .collect(Collectors.toList());
System.out.println(flatMappedList); // 输出: [apple, banana, cherry, date]

3.2 终止操作

终止操作是激活流计算的操作，调用终止操作时流会开始遍历并进行计算。常见的终止操作包括：

collect：将流中的元素收集到集合中，是最常用的终止操作。

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<String> result = list.stream()
                          .collect(Collectors.toList());
System.out.println(result); // 输出: [apple, banana, cherry]

forEach：对流中的每个元素进行操作，通常用于打印。

List<String> list = Arrays.asList("apple", "banana", "cherry");
list.stream()
    .forEach(System.out::println);
// 输出:
// apple
// banana
// cherry

reduce：用于对流中的元素进行累加或合并，通常用于求和、求最小值或求最大值。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .reduce(0, Integer::sum);
System.out.println(sum); // 输出: 15

anyMatch：检查流中的任何一个元素是否符合指定的条件。

List<String> list = Arrays.asList("apple", "banana", "cherry");
boolean hasApple = list.stream()
                       .anyMatch(s -> s.equals("apple"));
System.out.println(hasApple); // 输出: true

allMatch：检查流中的所有元素是否符合指定的条件。

List<String> list = Arrays.asList("apple", "banana", "cherry");
boolean allStartWithA = list.stream()
                            .allMatch(s -> s.startsWith("a"));
System.out.println(allStartWithA); // 输出: false

count：计算流中元素的数量。

List<String> list = Arrays.asList("apple", "banana", "cherry");
long count = list.stream()
                 .count();
System.out.println(count); // 输出: 3

4. Stream 的并行操作

Stream 还提供了并行流，它可以将计算任务分配给多个线程以加速处理。在调用 parallel() 方法后，流的操作会在多个线程中并行执行，从而提高大数据量处理的性能。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int sum = numbers.parallelStream()
                 .reduce(0, Integer::sum);
System.out.println(sum); // 输出: 21