超好用的特性：Stream 流

一、介绍

JDK 8引入了Stream API，它是Java中处理集合数据的一种新方式。Stream流提供了一种更简洁、更灵活的方式来对集合进行操作和处理。

Stream流可以看作是一种高级的迭代器，它可以对集合中的元素进行过滤、映射、排序、聚合等操作，而不需要显式地使用循环。这样可以使代码更加简洁、易读，并且可以充分利用多核处理器的优势。

Stream流的特点包括：

1. 延迟计算：Stream流中的操作是惰性执行的，只有在终止操作时才会触发计算。这种延迟计算的特性可以提高性能，因为只计算需要的结果。

2. 内部迭代：Stream流使用内部迭代器来遍历集合，这意味着不需要显式地编写循环来遍历集合。这样可以提高代码的简洁性和可读性。

3. 支持并行操作：Stream流可以很方便地进行并行操作，即将任务分成多个子任务并行执行，然后将结果合并。这可以提高处理大量数据的效率。

使用Stream流可以大大简化集合数据的处理，使代码更加简洁、易读，并且可以充分发挥多核处理器的优势。

二、相关操作

1. 创建Stream流：

   • 从集合创建：可以通过集合的stream()方法或parallelStream()方法来创建一个Stream流。
   • 从数组创建：可以使用Arrays类的stream()方法来创建一个Stream流。
   • 使用Stream.of()方法：可以直接传入多个元素来创建一个Stream流。
   • 使用Stream.generate()或Stream.iterate()方法：可以生成一个无限流。

2. Stream流的中间操作：

   • filter()：过滤掉不满足条件的元素。
   • map()：对元素进行映射转换。
   • flatMap()：将多个流合并成一个流。
   • distinct()：去除重复的元素。
   • sorted()：对元素进行排序。
   • limit()：限制元素的数量。
   • skip()：跳过指定数量的元素。

3. Stream流的终端操作：

   • forEach()：对每个元素执行指定操作。
   • collect()：将元素收集到一个集合中。
   • reduce()：将元素进行归约操作，得到一个最终结果。
   • count()：计算元素的数量。
   • min()和max()：找到最小值和最大值。
   • anyMatch()、allMatch()和noneMatch()：检查是否存在满足条件的元素。

三、实例

1. 过滤(filter)：筛选出集合中满足指定条件的元素。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

List<String> filteredNames = names.stream()
                                 .filter(name -> name.length() > 4)
                                 .collect(Collectors.toList());

System.out.println(filteredNames); // 输出：[Alice, Charlie]

2. 映射(map)：将集合中的元素进行转换。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> squaredNumbers = numbers.stream()
                                       .map(number -> number * number)
                                       .collect(Collectors.toList());

System.out.println(squaredNumbers); // 输出：[1, 4, 9, 16, 25]

3. 排序(sorted)：对集合中的元素进行排序。

List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);

List<Integer> sortedNumbers = numbers.stream()
                                     .sorted()
                                     .collect(Collectors.toList());

System.out.println(sortedNumbers); // 输出：[1, 2, 5, 8, 9]

4. 去重(distinct)：去除集合中的重复元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 3, 5);

List<Integer> distinctNumbers = numbers.stream()
                                       .distinct()
                                       .collect(Collectors.toList());

System.out.println(distinctNumbers); // 输出：[1, 2, 3, 4, 5]

5. 限制(limit)和跳过(skip)：限制集合中元素的数量或跳过指定数量的元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> limitedNumbers = numbers.stream()
                                      .limit(3)
                                      .collect(Collectors.toList());

System.out.println(limitedNumbers); // 输出：[1, 2, 3]

List<Integer> skippedNumbers = numbers.stream()
                                      .skip(2)
                                      .collect(Collectors.toList());

System.out.println(skippedNumbers); // 输出：[3, 4, 5]

6. 匹配(match)：检查集合中是否存在满足指定条件的元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

boolean anyMatch = numbers.stream()
                          .anyMatch(number -> number > 3);

System.out.println(anyMatch); // 输出：true

boolean allMatch = numbers.stream()
                          .allMatch(number -> number > 0);

System.out.println(allMatch); // 输出：true

boolean noneMatch = numbers.stream()
                           .noneMatch(number -> number < 0);

System.out.println(noneMatch); // 输出：true

7. 归约(reduce)：将集合中的元素进行合并操作，得到一个最终结果。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()
                 .reduce(0, (a, b) -> a + b);

System.out.println(sum); // 输出：15

int max = numbers.stream()
                 .reduce(Integer.MIN_VALUE, (a, b) -> a > b ? a : b);

System.out.println(max); // 输出：5

8. 遍历(forEach)：对集合中的每个元素执行指定操作。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

names.stream()
     .forEach(name -> System.out.println("Hello, " + name));

// 输出：
// Hello, Alice
// Hello, Bob
// Hello, Charlie

9. 统计(summarizing)：获取集合中元素的统计信息，如总数、平均值、最大值、最小值等。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

IntSummaryStatistics stats = numbers.stream()
                                    .mapToInt(Integer::intValue)
                                    .summaryStatistics();

System.out.println("Count: " + stats.getCount());
System.out.println("Sum: " + stats.getSum());
System.out.println("Average: " + stats.getAverage());
System.out.println("Max: " + stats.getMax());
System.out.println("Min: " + stats.getMin());

// 输出：
// Count: 5
// Sum: 15
// Average: 3.0
// Max: 5
// Min: 1

10. 分组(groupingBy)：根据指定条件对集合中的元素进行分组。

List<Person> people = Arrays.asList(
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 25),
    new Person("David", 35),
    new Person("Eve", 30)
);

Map<Integer, List<Person>> ageGroups = people.stream()
                                             .collect(Collectors.groupingBy(Person::getAge));

System.out.println(ageGroups);

// 输出：
// {25=[Person{name='Alice', age=25}, Person{name='Charlie', age=25}], 
//  30=[Person{name='Bob', age=30}, Person{name='Eve', age=30}], 
//  35=[Person{name='David', age=35}]}

11. 并行处理(parallelStream)：使用并行流来并行处理集合中的元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.parallelStream()
                 .reduce(0, (a, b) -> a + b);

System.out.println(sum); // 输出：15

12. flatMap操作：将多个流合并成一个流。

List<List<Integer>> numberLists = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9)
);

List<Integer> flattenedList = numberLists.stream()
                                         .flatMap(List::stream)
                                         .collect(Collectors.toList());

System.out.println(flattenedList);

// 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

13. 查找(findFirst和findAny)：查找集合中满足指定条件的元素。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

Optional<Integer> firstEvenNumber = numbers.stream()
                                           .filter(number -> number % 2 == 0)
                                           .findFirst();

System.out.println(firstEvenNumber); // 输出：Optional[2]

Optional<Integer> anyEvenNumber = numbers.stream()
                                         .filter(number -> number % 2 == 0)
                                         .findAny();

System.out.println(anyEvenNumber); // 输出：Optional[2]（可能不同于findFirst的结果）

14. 去除空值(filterNotNull)：过滤掉集合中的空值。

List<String> names = Arrays.asList("Alice", null, "Bob", null, "Charlie");

List<String> nonNullNames = names.stream()
                                 .filter(Objects::nonNull)
                                 .collect(Collectors.toList());

System.out.println(nonNullNames); // 输出：[Alice, Bob, Charlie]

15. 使用自定义操作(customOperation)：根据自己的需求编写自定义的操作。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<String> uppercaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

System.out.println(uppercaseNames); // 输出：[ALICE, BOB, CHARLIE]