Java 9 - 流 API 的增强

素颜马尾好姑娘i 2023-10-13 12:55 19阅读 0赞

## Optional 类的 stream() 方法 ##

package com.lfsun.java9study.stream;
    
    import java.util.Optional;
    import java.util.stream.Stream;
    
    /**
     *     Optional 类的 stream() 方法：Java 9为 Optional 类添加了 stream() 方法，
     *     允许将一个包含单个元素的 Optional 对象转换为包含该元素的流。如果 Optional 对象为空，则生成一个空流。
     */
    public class OptionalStreamExample {
        
        public static void main(String[] args) {
        
            // 包含单个元素的Optional对象
            Optional<String> optional = Optional.of("Hello");
            Stream<String> stream1 = optional.stream();
            stream1.forEach(System.out::println); // 输出: Hello
    
            // 空的Optional对象
            Optional<String> emptyOptional = Optional.empty();
            Stream<String> stream2 = emptyOptional.stream();
            stream2.forEach(System.out::println); // 无输出，生成空流
        }
    }

## Stream 接口的 iterate() 方法 ##

package com.lfsun.java9study.stream;
    
    import java.util.stream.Stream;
    
    /**
     *     Stream 接口的 iterate() 方法的重载版本：Java 9为 Stream.iterate() 方法添加了一个重载版本，
     *     允许指定一个谓词（Predicate）来定义流的终止条件。这样，可以更灵活地控制流的生成。
     */
    public class StreamIterateExample {
        
        public static void main(String[] args) {
        
            // 使用重载的iterate方法生成流
            //  seed：初始值，流的第一个元素。
            //  predicate：谓词，用于定义流的终止条件。当谓词返回false时，流将终止。
            //  next：根据前一个元素生成下一个元素的函数。n -> n + 1肩比 for循环的 i++
            Stream<Integer> stream = Stream.iterate(1, n -> n <= 10, n -> n * 2);
            stream.forEach(System.out::println);
        }
    }

## Stream 接口的 ofNullable() 方法 ##

package com.lfsun.java9study.stream;
    
    import java.util.stream.Stream;
    
    /**
     * Stream 接口的 ofNullable() 方法：Java 9引入了 Stream.ofNullable() 方法，允许在流中包含一个可能为 null 的单个元素。
     * 如果元素为 null，则生成一个空流；否则，生成包含该元素的单元素流。
     */
    public class StreamOfNullableExample {
        
        public static void main(String[] args) {
        
            // 可能为null的元素
            String nullableElement = "Hello";
            Stream<String> stream1 = Stream.ofNullable(nullableElement);
            stream1.forEach(System.out::println); // 输出: Hello
    
            // null元素
            nullableElement = null;
            Stream<String> stream2 = Stream.ofNullable(nullableElement);
            stream2.forEach(System.out::println); // 无输出，生成空流
        }
    }

## Stream 接口的 takeWhile() 和 dropWhile() 方法 ##

package com.lfsun.java9study.stream;
    
    import java.util.stream.Stream;
    
    /**
     *     Stream 接口的 takeWhile() 和 dropWhile() 方法：Java 9引入了 Stream.takeWhile() 和 Stream.dropWhile() 方法，
     *     它们允许根据指定的条件逐个获取或丢弃流的元素，直到遇到第一个不满足条件的元素。这样可以更方便地进行流的截取和过滤操作。
     */
    public class StreamTakeDropWhileExample {
        
        public static void main(String[] args) {
        
            // takeWhile示例
            Stream<Integer> stream1 = Stream.of(2, 4, 6, 1, 8, 10, 3);
            stream1.takeWhile(n -> n % 2 == 0)
                    .forEach(System.out::println); // 输出：2 4 6
    
            // dropWhile示例
            Stream<Integer> stream2 = Stream.of(2, 4, 6, 1, 8, 10, 3);
            stream2.dropWhile(n -> n % 2 == 0)
                    .forEach(System.out::println); // 输出：1 8 10 3
        }
    }

## 新的收集器 ##

package com.lfsun.java9study.stream;
    
    import java.util.List;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    public class FilteringCollectorExample {
        
        public static void main(String[] args) {
        
            Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    
            List<Integer> evenNumbers = stream.collect(
                    Collectors.filtering(n -> n % 2 == 0, Collectors.toList())
            );
    
            System.out.println(evenNumbers); // 输出: [2, 4, 6, 8, 10]
        }
    }

package com.lfsun.java9study.stream;
    
    import java.util.List;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    public class FlatMappingCollectorExample {
        
        public static void main(String[] args) {
        
            Stream<List<Integer>> stream = Stream.of(
                    List.of(1, 2, 3),
                    List.of(4, 5, 6),
                    List.of(7, 8, 9)
            );
    
            List<Integer> flattenedList = stream.collect(
                    Collectors.flatMapping(List::stream, Collectors.toList())
            );
    
            System.out.println(flattenedList); // 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]
        }
    }

package com.lfsun.java9study.stream;
    
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    public class GroupingByConcurrentExample {
        
        public static void main(String[] args) {
        
            Stream<String> stream = Stream.of("apple", "banana", "cat", "dog", "elephant");
    
            Map<Integer, List<String>> lengthToWords = stream.collect(
                    Collectors.groupingByConcurrent(String::length)
            );
    
            System.out.println(lengthToWords); // 输出: {
        3=[cat, dog], 5=[apple], 6=[banana], 8=[elephant]}
        }
    }

## 完整代码案例地址 ##

[Java9 - 流 API 的增强][Java9 - _ API]

[Java9 - _ API]: https://gitee.com/lfsun666/Java-11-study/tree/master/Java-9-study/src/main/java/com/lfsun/java9study/stream