Java8新特性Stream流怎么使用

Java 8引入了Stream API，它是一种用于处理集合数据的强大工具。Stream API 提供了一种声明式的方式来处理数据，使得代码更加简洁、易读，并且可以利用多核架构进行并行处理。本文将介绍Stream的基本概念、常用操作以及如何使用它来简化集合操作。

1. 什么是Stream？

Stream 是 Java 8 中引入的一个新抽象，它允许你以声明式的方式处理数据集合。Stream 不是数据结构，它不会存储数据，而是对数据源（如集合、数组等）进行操作。Stream 提供了一系列的操作，如过滤、映射、排序、聚合等，这些操作可以链式调用，形成一个流水线。

1.1 Stream的特点

• 惰性求值：Stream 的操作分为中间操作和终端操作。中间操作（如filter、map）不会立即执行，只有在终端操作（如collect、forEach）被调用时才会执行。
• 不可变性：Stream 不会修改原始数据源，而是生成一个新的Stream。
• 并行处理：Stream 可以很容易地并行化处理数据，只需调用parallel()方法即可。

2. 创建Stream

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

2.1 从集合创建

最常见的创建Stream的方式是从集合中创建：

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

2.2 从数组创建

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

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

2.3 使用Stream.of()

Stream.of()方法可以接受任意数量的参数，并返回一个Stream：

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

2.4 使用Stream.generate()

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

Stream<String> stream = Stream.generate(() -> "hello").limit(5);

2.5 使用Stream.iterate()

Stream.iterate()方法可以生成一个无限流，通过迭代函数生成元素：

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

3. Stream的常用操作

Stream 提供了丰富的操作，可以分为中间操作和终端操作。

3.1 中间操作

中间操作返回一个新的Stream，可以链式调用。

3.1.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.1.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.1.3 flatMap()

flatMap()方法用于将多个流合并为一个流：

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

3.1.4 sorted()

sorted()方法用于对元素进行排序：

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

3.2 终端操作

终端操作会触发流的处理，并返回一个结果或产生副作用。

3.2.1 forEach()

forEach()方法用于遍历流中的每个元素：

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

3.2.2 collect()

collect()方法用于将流中的元素收集到一个集合中：

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

3.2.3 reduce()

reduce()方法用于将流中的元素归约为一个值：

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

3.2.4 count()

count()方法用于统计流中的元素个数：

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

3.2.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("z"));
// anyMatch: true
// allMatch: false
// noneMatch: true

4. 并行流

Stream 可以很容易地并行化处理数据，只需调用parallel()方法即可：

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

5. 总结

Java 8 的Stream API 提供了一种强大的工具来处理集合数据。通过Stream，你可以以声明式的方式编写代码，使得代码更加简洁、易读。Stream 的中间操作和终端操作可以链式调用，形成一个流水线，从而高效地处理数据。此外，Stream 还支持并行处理，可以充分利用多核架构的优势。

掌握Stream的使用，可以极大地提高代码的可读性和性能，是Java开发者必备的技能之一。