超好用的特性：Stream 流

女爷i 2024-03-16 21:16 73阅读 0赞

## 一、介绍 ##

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]

1.  映射(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]

1.  排序(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]

1.  去重(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]

1.  限制(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]

1.  匹配(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

1.  归约(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

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

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
    
    names.stream()
         .forEach(name -> System.out.println("Hello, " + name));
    
    // 输出：
    // Hello, Alice
    // Hello, Bob
    // Hello, Charlie

1.  统计(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

1.  分组(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}]}

1.  并行处理(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

1.  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]

1.  查找(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的结果）

1.  去除空值(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]

1.  使用自定义操作(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]