Java8 Stream流常用方法是什么

Java 8引入了Stream API，它提供了一种高效且易于使用的方式来处理集合数据。Stream API允许我们以声明式的方式处理数据，并且可以轻松地并行化操作。本文将详细介绍Java 8中Stream流的常用方法，并通过示例代码展示如何使用这些方法。

1. Stream简介

Stream是Java 8中引入的一个新抽象，它允许我们以声明式的方式处理数据集合。Stream可以看作是对集合数据的高级迭代器，它提供了丰富的操作方法来处理数据，如过滤、映射、排序、聚合等。

Stream的主要特点包括：

• 惰性求值：Stream操作是惰性的，只有在终端操作执行时才会真正开始处理数据。
• 不可变性：Stream操作不会修改原始数据源，而是生成一个新的Stream。
• 并行处理：Stream可以轻松地并行化操作，以提高处理效率。

2. 创建Stream

在开始使用Stream之前，我们需要先创建一个Stream。Java 8提供了多种创建Stream的方式：

2.1 从集合创建Stream

我们可以通过集合的stream()方法或parallelStream()方法来创建一个Stream：

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

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()方法创建一个无限Stream，它通过提供的Supplier生成元素：

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

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

我们可以使用Stream.iterate()方法创建一个无限Stream，它通过迭代生成元素：

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

3. Stream常用方法

Stream提供了丰富的操作方法，这些方法可以分为两类：中间操作和终端操作。

• 中间操作：返回一个新的Stream，允许我们链式调用多个操作。
• 终端操作：触发Stream的处理并返回结果或产生副作用。

3.1 中间操作

3.1.1 filter()

filter()方法用于过滤Stream中的元素，只保留满足条件的元素：

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()方法用于将Stream中的每个元素映射为另一个元素：

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()方法用于将Stream中的每个元素映射为一个Stream，然后将这些Stream合并为一个Stream：

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 distinct()

distinct()方法用于去除Stream中的重复元素：

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

3.1.5 sorted()

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

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

我们还可以传入一个Comparator来自定义排序规则：

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

3.1.6 peek()

peek()方法用于对Stream中的每个元素执行操作，通常用于调试：

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

3.1.7 limit()

limit()方法用于截取Stream中的前N个元素：

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

3.1.8 skip()

skip()方法用于跳过Stream中的前N个元素：

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

3.2 终端操作

3.2.1 forEach()

forEach()方法用于对Stream中的每个元素执行操作：

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

3.2.2 collect()

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

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

我们还可以使用Collectors类提供的其他方法来收集元素，如toSet()、toMap()等：

Set<String> set = list.stream()
                      .collect(Collectors.toSet());
Map<String, Integer> map = list.stream()
                               .collect(Collectors.toMap(Function.identity(), String::length));

3.2.3 reduce()

reduce()方法用于将Stream中的元素通过指定的操作进行归约：

List<Integer> list = Arrays.asList(1, 2, 3, 4);
Optional<Integer> result = list.stream()
                               .reduce((a, b) -> a + b);
// result: Optional[10]

我们还可以提供一个初始值：

int result = list.stream()
                 .reduce(0, (a, b) -> a + b);
// result: 10

3.2.4 count()

count()方法用于统计Stream中的元素数量：

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

3.2.5 anyMatch()

anyMatch()方法用于判断Stream中是否有任意一个元素满足指定条件：

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

3.2.6 allMatch()

allMatch()方法用于判断Stream中的所有元素是否都满足指定条件：

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

3.2.7 noneMatch()

noneMatch()方法用于判断Stream中是否没有任何元素满足指定条件：

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

3.2.8 findFirst()

findFirst()方法用于返回Stream中的第一个元素：

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

3.2.9 findAny()

findAny()方法用于返回Stream中的任意一个元素：

List<String> list = Arrays.asList("a", "b", "c");
Optional<String> result = list.stream().findAny();
// result: Optional["a"] 或 Optional["b"] 或 Optional["c"]

3.2.10 min()

min()方法用于返回Stream中的最小元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4);
Optional<Integer> result = list.stream()
                              .min(Integer::compareTo);
// result: Optional[1]

3.2.11 max()

max()方法用于返回Stream中的最大元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4);
Optional<Integer> result = list.stream()
                              .max(Integer::compareTo);
// result: Optional[4]

3.2.12 toArray()

toArray()方法用于将Stream中的元素转换为数组：

List<String> list = Arrays.asList("a", "b", "c");
String[] array = list.stream().toArray(String[]::new);
// array: ["a", "b", "c"]

4. 并行Stream

Stream API支持并行处理，我们可以通过parallelStream()方法或parallel()方法将Stream转换为并行Stream：

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

并行Stream会自动将任务分配到多个线程上执行，从而提高处理效率。需要注意的是，并行处理并不总是比串行处理更快，特别是在数据量较小或任务本身较为简单的情况下。

5. 总结

Java 8的Stream API为我们提供了一种高效且易于使用的方式来处理集合数据。通过Stream，我们可以以声明式的方式对数据进行过滤、映射、排序、聚合等操作，并且可以轻松地并行化处理。本文详细介绍了Stream的常用方法，并通过示例代码展示了如何使用这些方法。

Stream API的强大之处在于它的灵活性和可组合性，我们可以通过链式调用多个操作来处理数据，而无需编写复杂的循环和条件判断。此外，Stream的惰性求值特性也使得它在处理大数据集时更加高效。

希望本文能帮助你更好地理解和使用Java 8中的Stream API，并在实际开发中发挥其强大的功能。