阅读全文

⭐⭐⭐ Spring Boot 项目实战	⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》	《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》	《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》	《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》	《Java 面试题 + Java 学习指南》

摘要: 原创出处 程序猿DD 「DD编辑部」欢迎转载，保留摘要，谢谢！

• 1. 快速过滤空值：Stream.ofNullable
• 2. 流式迭代：Stream.iterate（）
• 3. 集合转换：collectingAndThen（）
• 4. 删除和截取：dropWhile（）、takeWhile（）
• 5. 整数流：IntStream
• 6. 应用多个收集器：teeing（）
• 7. 合并流：Stream.concat（）
• 8. 分组：Collectors.partitioningBy

---

🙂🙂🙂关注微信公众号：【芋道源码】有福利：

1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
4. 新的源码解析文章实时收到通知。每周更新一篇左右。
5. 认真的源码交流微信群。

---

分享8个开箱即用的API，方便日常处理集合。

欢迎关注我的Java新特性专栏：https://www.didispace.com/java-features/

1. 快速过滤空值：Stream.ofNullable

该方法是在 Java 9 中引入的，有助于过滤集合中的所有空值，从而可能使我们避免空指针异常。

在下面的示例中，有一个包含 null 的List。此时，我们可以使用Stream.ofNullable方法对其进行过滤。

List<String> names = Arrays.asList("Alice", null, "Bob", null, "Charlie");
        List<String> nonNuLLNames = names.stream()
        .flatMap(Stream::ofNullable)
        .collect(Collectors.toList());
        System.out.println(nonNuLLNames);

执行上述代码，将输出：

[Alice, Bob, Charlie]

2. 流式迭代：Stream.iterate()

Stream.iterate()方法用于创建无限的序列流。它采用种子和一元函数，将函数应用于前一个元素。

在下面的例子中，我们的种子是0，一元运算函数是 n -> n+2。

Stream.iterate(seed: 0, n -> n+2)
        .Limit( maxsize: 10)
        .forEach(e-> {
        System,out printin(e)
        });

执行上述代码，将输出：

0
        2
        4
        6
        8
        10
        12
        14
        16
        18

注意：由于Stream.iterate()生成的是无限序列流。因此我们应该定义终止条件，例如：limit、findFirst 或 findAny 等，以避免无限循环。

3. 集合转换：collectingAndThen()

collectingAndThen()方法是在 Java 8 中引入的。它是一种特殊的收集器，允许您对另一个收集器的结果执行特殊类型的转换。

在下面的示例中，我们的收集器通过首先使用索引到大写操作进行映射，然后使该映射成为不可修改的Map进行转换。

List<String> fruits = Arrays.asList("apple", "banana","orange");
        Map<Integer, String> result = fruits.stream()
        .collect(Collectors.collectingAndThen(
        Collectors.toMap(fruits::index0f,String::toUpperCase),
        Collections::unmodifiableMap
        ));
        System.out.println(result)

执行上述代码，将输出：

{0=APPLE, 1=BANANA, 2=ORANGE}

4. 删除和截取：dropWhile()、takeWhile()

dropWhile()和takeWhile()方法是在 java9 中引入的，用于连续处理流。

• takeWhile()：返回符合条件的元素流
• dropWhile()：从元素流中删除符合条件的元素

在下面的示例中，我们删除小于3的元素，然后返回元素小于6的元素流。

List<Integer> numbers = List.of(1,2,3,4,5,6,7);
        numbers.stream()
        .dropWhile(n -> n < 3)
        .takeWhile(n -> n < 6)
        .forEach(System.out::println);

执行上述代码，将输出：

3
        4
        5

5. 整数流：IntStream

IntStream 在 Java 8 中引入，用于快速生成整数流，常用有的以下两个方法：

• IntStream.range() 方法生成一个整数流，该整数流不包含结尾数字
• IntStream.rangeClosed() 方法生成一个整数流，该整数流包含结尾数字

下面的例子，可以清晰的看到区别：

// Prints 1,2,3,4
IntStream.range(1,5).forEach(System.out::println);
// Prints 1,2,3,4,5
        IntStream.rangeClosed(1,5).forEach(System.out::println);

6. 应用多个收集器：teeing()

Java 12 中引入的teeing()方法是为了我们可以在元素流上一起应用两个单独的收集器而创建的。

在下面的示例中，我们使用teeing()计算元素流的最大值和最小值，然后将结果以Map形式返回。

Stream<Integer> nums = Stream.of( ...values: 1 2,3 4);
        Map<String, Integer> collect = nums.collect(Collectors.teeing(
        ColLectors.maxBy(Integer::compareTo),
        CoLlectors.minBy(Integer::compareTo),
        (e1, e2) -> Map.of( k1: "min", e1.get(), k2: "max", e2.get())
        ));

        System.out.println(collect);

执行上述代码，将输出：

{max=1, min=4}

7. 合并流：Stream.concat()

Stream.concat()方法可以用来连接两个流并生成一个新流。

Stream<Integer> stream1 = Stream.of(...values: 1,2,3);
        Stream<Integer> stream2 = Stream.of(...values: 4,5,6);
        Stream.concat(stream1, stream2)
        .forEach(System.out::println);

执行上述代码，将输出：

1
        2
        3
        4
        5
        6

8. 分组：Collectors.partitioningBy

Collectors.partitioningBy可以用来对流进行分组。

在下面的示例中，我们根据元素的字符串长度分为两个不同的组。

Map<Boolean, List<String>> result1 = Stream.of(...values: "apple", "banana", "orange", "grape")
        .collect(Collectors.partitioningBy(f -> f.length() > 5));

        System.out.println(result1);

执行上述代码，将输出：

{false=[apple, grape], true=[banana, orange]}