深入理解Java 8的流式API：简化代码，提升效率

深入理解Java 8的流式API：简化代码，提升效率

Java 8引入了Stream API，它提供了一种新的抽象，可以更方便地对集合进行操作和处理。

想深入了解Stream流的小伙伴可以看看我以前的源码文章：

1、 深度解析Java JDK 1.8中Stream流的源码实现：带你探寻数据流的奥秘_jdk中的流-CSDN博客

2、 Java流操作解析：深度剖析中间操作、终端操作与并行处理机制_流操作 中间操作有哪些-CSDN博客

一、流 Stream

Stream API允许我们以一种声明性的方式处理数据，支持函数式编程风格。

String流主要特性和用法：

1. 创建流：
   • 从集合创建：通过集合的stream()方法或parallelStream()方法来创建流。
   • 从数组创建：使用Arrays.stream(array)方法。
   • 使用静态工厂方法：如Stream.of()、IntStream.range()等。
2. 中间操作：
   • filter(Predicate)：根据条件过滤流中的元素。
   • map(Function)：将流中的每个元素映射为另一个元素。
   • sorted()：对流进行排序。
   • distinct()：去除流中重复的元素。
   • limit(long)：限制流中元素的数量。
3. 终端操作：
   • forEach(Consumer)：对流中的每个元素执行操作。
   • collect(Collectors)：将流元素归约和汇总成一个值，如List、Set、Map等。
   • reduce()：归约操作，可以将流中的元素反复结合起来，得到一个值。
   • min()和max()：找出流中的最小和最大值。
   • count()：返回流中元素的总数。
   • anyMatch(), allMatch(), noneMatch()：检查流中是否存在满足条件的元素。

如何使用Java 8的Stream API来操作集合：

public static void main(String[] args) {
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");

        // 打印非空字符串的数量：使用`filter`方法过滤出非空字符串，然后使用`count`方法获取数量
        long count = strings.stream()
                .filter(string -> !string.isEmpty())
                .count();
        System.out.println("非空字符串数量：" + count);

        // 打印非空字符串的列表：使用`filter`方法过滤出非空字符串，然后使用`collect(Collectors.toList())`将结果收集为List
        List<String> filtered = strings.stream()
                .filter(string -> !string.isEmpty())
                .collect(Collectors.toList());
        System.out.println("非空字符串列表：" + filtered);

        // 使用逗号连接非空字符串：使用`filter`方法过滤出非空字符串，然后使用`collect(Collectors.joining(", "))`连接成一个字符串
        String mergedString = strings.stream()
                .filter(string -> !string.isEmpty())
                .collect(Collectors.joining(", "));
        System.out.println("连接后的字符串：" + mergedString);

        // 获取最长的字符串：使用`max`方法找到最长的字符串，如果找不到则返回空字符串
        String longestString = strings.stream()
                .max((s1, s2) -> s1.length() - s2.length())
                .orElse("");
        System.out.println("最长的字符串：" + longestString);
    }

二、Int | Long | Double Stream

IntStream、LongStream 和 DoubleStream 是基本类型的流，提供了对整数、长整数和双精度浮点数的高效处理。

IntStream 的元素类型为 int：

• 创建方式：
  • range(int startInclusive, int endExclusive)：创建一个范围在 [startInclusive, endExclusive) 内的 IntStream。
  • rangeClosed(int startInclusive, int endInclusive)：创建一个范围在 [startInclusive, endInclusive] 内的 IntStream。
  • of(int... values)：从一组整数值创建一个 IntStream。
• 常用方法：
  • sum()：对流中的所有整数求和。
  • average()：计算流中所有整数的平均值。
  • min() 和 max()：找出流中的最小和最大值。
  • forEach(IntConsumer action)：对流中的每个整数执行指定操作。

LongStream 的元素类型为 long：

• 创建方式：
  • range(long startInclusive, long endExclusive)：创建一个范围在 [startInclusive, endExclusive) 内的 LongStream。
  • rangeClosed(long startInclusive, long endInclusive)：创建一个范围在 [startInclusive, endInclusive] 内的 LongStream。
  • of(long... values)：从一组长整数值创建一个 LongStream。
• 常用方法：
  • sum()：对流中的所有长整数求和。
  • average()：计算流中所有长整数的平均值。
  • min() 和 max()：找出流中的最小和最大值。
  • forEach(LongConsumer action)：对流中的每个长整数执行指定操作。

DoubleStream 的元素类型为 double：

• 创建方式：
  • of(double... values)：从一组双精度浮点数值创建一个 DoubleStream。
  • range(double startInclusive, double endInclusive)：创建一个在指定范围内的 DoubleStream。
• 常用方法：
  • sum()：对流中的所有双精度浮点数求和。
  • average()：计算流中所有双精度浮点数的平均值。
  • min() 和 max()：找出流中的最小和最大值。
  • forEach(DoubleConsumer action)：对流中的每个双精度浮点数执行指定操作。

使用 IntStream、LongStream 和 DoubleStream 基本的操作：

 public static void main(String[] args) {
        // IntStream 
        IntStream.range(1, 5)
                .forEach(System.out::print);  
        // 输出：1234
        System.out.println();

        int sum = IntStream.of(1, 2, 3, 4, 5)
                .sum();  
     	// 计算总和：15
        System.out.println("Sum of integers: " + sum);

        // LongStream 
        long max = LongStream.rangeClosed(1, 10)
                .max()
                .orElse(0);  
     	// 找出最大值：10
        System.out.println("Max of long integers: " + max);

        // DoubleStream
        double average = DoubleStream.of(1.5, 2.5, 3.5, 4.5)
                .average()
                .orElse(0.0);  
     	// 计算平均值：3.0
        System.out.println("Average of doubles: " + average);
    }

三、收集器 Collectors

收集器（Collectors）用于将流的元素累积到集合中，或者进行聚合操作。在使用流进行数据处理时，收集器是非常有用的工具，它们能够简化代码并提高效率。

常用的收集器及其用法：

1. toList()

   • 将流中的元素收集到一个列表中。

   List<String> list = stream.collect(Collectors.toList());
   

2. toSet()

   • 将流中的元素收集到一个集合（集合元素不重复）中。

   Set<String> set = stream.collect(Collectors.toSet());
   

3. toMap()

   • 将流中的元素根据指定的 keyMapper 和 valueMapper 转换为 Map。

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

4. joining()

   • 连接流中的元素成为一个字符串。

   String result = stream.collect(Collectors.joining(", "));
   

5. groupingBy()

   • 根据某个属性对流中的元素进行分组，生成一个 Map，键为属性，值为对应属性的元素列表。

   Map<Integer, List<String>> groupedByLength = stream.collect(Collectors.groupingBy(String::length));
   

6. partitioningBy()

   • 根据一个条件将流中的元素分为两组，生成一个 Map，键为 true/false，值为满足条件的元素列表。

   Map<Boolean, List<String>> partitioned = stream.collect(Collectors.partitioningBy(s -> s.length() > 3));
   

7. summarizingInt() / summarizingDouble() / summarizingLong()

   • 统计流中元素的汇总信息，如最大值、最小值、平均值、总和等。

   IntSummaryStatistics stats = stream.collect(Collectors.summarizingInt(String::length));
   
   

如何将一个字符串流收集成一个列表，并按长度分组：

public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "grape", "pear", "orange");

        // 将流中的元素收集到一个列表中
        List<String> wordList = words.stream()
                                    .collect(Collectors.toList());
        System.out.println("List of words: " + wordList);

        // 根据字符串长度分组
        Map<Integer, List<String>> groupedByLength = words.stream()
                                                        .collect(Collectors.groupingBy(String::length));
        System.out.println("Words grouped by length: " + groupedByLength);
    }

智者的梦再美，也不如愚人实干的脚印