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()方法来创建一个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()方法来创建一个无限Stream：

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提供了丰富的操作方法，下面我们将详细介绍这些方法。

3.1 forEach()

forEach()方法用于遍历Stream中的每个元素，并对每个元素执行指定的操作。

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

3.2 map()

map()方法用于将Stream中的每个元素映射为另一个元素。它接受一个Function函数式接口作为参数，该接口定义了一个apply()方法，用于将输入元素转换为输出元素。

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

3.3 filter()

filter()方法用于过滤Stream中的元素。它接受一个Predicate函数式接口作为参数，该接口定义了一个test()方法，用于判断元素是否满足条件。

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

3.4 sorted()

sorted()方法用于对Stream中的元素进行排序。它可以接受一个Comparator作为参数，用于指定排序规则。

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

3.5 distinct()

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

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

3.6 limit()

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

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

3.7 skip()

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

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

3.8 reduce()

reduce()方法用于将Stream中的元素组合起来，生成一个单一的结果。它接受一个BinaryOperator函数式接口作为参数，该接口定义了一个apply()方法，用于将两个元素组合起来。

List<Integer> list = Arrays.asList(1, 2, 3, 4);
Optional<Integer> sum = list.stream()
                            .reduce((a, b) -> a + b);
System.out.println(sum.get()); // 输出: 10

3.9 collect()

collect()方法用于将Stream中的元素收集到一个集合中。它接受一个Collector作为参数，用于指定收集方式。

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

3.10 anyMatch()

anyMatch()方法用于判断Stream中是否有任意一个元素满足指定的条件。它接受一个Predicate函数式接口作为参数。

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

3.11 allMatch()

allMatch()方法用于判断Stream中的所有元素是否都满足指定的条件。它接受一个Predicate函数式接口作为参数。

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

3.12 noneMatch()

noneMatch()方法用于判断Stream中是否没有任何元素满足指定的条件。它接受一个Predicate函数式接口作为参数。

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

3.13 findFirst()

findFirst()方法用于返回Stream中的第一个元素。它返回一个Optional对象，如果Stream为空，则返回一个空的Optional。

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

3.14 findAny()

findAny()方法用于返回Stream中的任意一个元素。它返回一个Optional对象，如果Stream为空，则返回一个空的Optional。

List<String> list = Arrays.asList("a", "b", "c");
Optional<String> anyElement = list.stream()
                                  .findAny();
System.out.println(anyElement.get()); // 输出: a (或其他任意元素)

3.15 count()

count()方法用于返回Stream中元素的数量。

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

3.16 flatMap()

flatMap()方法用于将Stream中的每个元素映射为一个Stream，然后将这些Stream合并为一个Stream。

List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d")
);
List<String> flatList = listOfLists.stream()
                                   .flatMap(List::stream)
                                   .collect(Collectors.toList());
System.out.println(flatList); // 输出: [a, b, c, d]

3.17 peek()

peek()方法用于对Stream中的每个元素执行指定的操作，但不改变Stream的内容。它通常用于调试。

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

3.18 toArray()

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

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

3.19 min()和max()

min()和max()方法分别用于返回Stream中的最小值和最大值。它们接受一个Comparator作为参数，用于指定比较规则。

List<Integer> list = Arrays.asList(1, 2, 3, 4);
Optional<Integer> min = list.stream()
                            .min(Integer::compareTo);
Optional<Integer> max = list.stream()
                            .max(Integer::compareTo);
System.out.println(min.get()); // 输出: 1
System.out.println(max.get()); // 输出: 4

3.20 summaryStatistics()

summaryStatistics()方法用于返回Stream中元素的统计信息，包括数量、总和、最小值、最大值和平均值。

List<Integer> list = Arrays.asList(1, 2, 3, 4);
IntSummaryStatistics stats = list.stream()
                                .mapToInt(Integer::intValue)
                                .summaryStatistics();
System.out.println(stats.getCount());    // 输出: 4
System.out.println(stats.getSum());      // 输出: 10
System.out.println(stats.getMin());      // 输出: 1
System.out.println(stats.getMax());      // 输出: 4
System.out.println(stats.getAverage()); // 输出: 2.5

4. 并行Stream

Stream API支持并行处理，我们可以通过parallelStream()方法将Stream转换为并行Stream，从而利用多核处理器的优势。

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

需要注意的是，并行Stream并不总是比顺序Stream更快，它取决于数据量和操作的复杂性。在某些情况下，并行处理可能会引入额外的开销，反而降低性能。

5. 总结

Java 8的Stream API提供了一种高效且易于使用的方式来处理集合数据。通过Stream，我们可以以声明式的方式处理数据，并且可以轻松地并行化操作。本文详细介绍了Stream的常用方法，包括forEach()、map()、filter()、sorted()、distinct()、limit()、skip()、reduce()、collect()、anyMatch()、allMatch()、noneMatch()、findFirst()、findAny()、count()、flatMap()、peek()、toArray()、min()、max()和summaryStatistics()等。掌握这些方法，可以让我们更加高效地处理集合数据。