Java中Stream流

Java中Stream流

Stream

使用flatMap处理嵌套集合:
有一个对象列表，每个对象又包含一个列表，可以使用flatMap来“展平”这个结构。

List<List<String>> listOfLists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d")
);
List<String> flatList = listOfLists.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList());

使用peek进行调试:
peek方法可以在流的中间操作中插入一个动作，比如打印日志，而不会影响流的最终结果。

List<String> result = list.stream()
    .filter(s -> s.startsWith("a"))
    .peek(System.out::println) // 打印中间结果
    .map(String::toUpperCase)
    .collect(Collectors.toList());

peek可以用来调试也可以塞对象，不改变流，如果你这个里面有对象，比如xxx.setXXX() 那么也会修改这个对象

使用groupingBy进行分组:
Collectors.groupingBy可以根据某个属性对元素进行分组。

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

使用reduce进行复杂聚合:
reduce方法可以用来执行更复杂的聚合操作，比如连接字符串。

String joined = list.stream()
    .reduce("", (a, b) -> a + ", " + b);

使用IntStream、LongStream和DoubleStream进行基本类型操作

对于基本数据类型（int、long、double），可以使用IntStream、LongStream和DoubleStream来提高性能和内存使用效率。

int sum = IntStream.of(1, 2, 3, 4, 5).sum();

使用Stream.generate和Stream.iterate生成无限流

Stream.generate可以用来创建一个无限流，其中每个元素都是通过一个Supplier函数生成的。

Stream<Double> randoms = Stream.generate(Math::random);

Stream.iterate可以用来创建一个无限流，其中每个元素都是基于前一个元素计算得到的。

Stream<Integer> naturals = Stream.iterate(0, n -> n + 1);

使用Stream.collect的自定义收集器

collect方法非常灵活，可以配合自定义的Collector来实现复杂的收集逻辑。

Collector<T, ?, LinkedList<T>> toLinkedList = Collector.of(
    LinkedList::new,
    LinkedList::add,
    (left, right) -> { left.addAll(right); return left; }
);
List<T> linkedListOfT = stream.collect(toLinkedList);

使用Stream.concat合并两个流

Stream.concat方法可以用来合并两个流。

Stream<String> stream1 = Stream.of("a", "b", "c");
Stream<String> stream2 = Stream.of("d", "e", "f");
Stream<String> combined = Stream.concat(stream1, stream2);

使用Stream.peek进行调试

peek方法可以在流的处理过程中插入一个操作，用于调试。

List<String> result = list.stream()
    .filter(s -> s.startsWith("a"))
    .peek(System.out::println) // 打印中间结果
    .map(String::toUpperCase)
    .collect(Collectors.toList());

使用Stream.anyMatch, Stream.allMatch, 和 Stream.noneMatch

这三个方法用于对流中的元素进行断言检查。

boolean anyStartsWithA = list.stream().anyMatch(s -> s.startsWith("a"));
boolean allStartsWithA = list.stream().allMatch(s -> s.startsWith("a"));
boolean noneStartsWithZ = list.stream().noneMatch(s -> s.startsWith("z"));

使用Stream.ofNullable处理可能为null的元素

Stream.ofNullable可以用来创建一个元素可能为null的流。

Stream<String> stream = Stream.ofNullable(getNullableValue());

使用flatMap处理多层嵌套结构

当处理多层嵌套的集合时，flatMap可以用来将多层结构“展平”成单个流。

Stream<List<List<String>>> nestedLists = Stream.of(listOfLists);
Stream<String> flatStream = nestedLists.flatMap(List::stream).flatMap(List::stream);

Optional

1. 使用orElseGet延迟加载:
   orElseGet提供一个Supplier函数，只有在Optional为空时才调用。

   Optional<String> optional = Optional.ofNullable(getValue());
   String value = optional.orElseGet(() -> computeValue());
   

2. 使用map和orElse链式处理:
   map可以用来转换Optional中的值，如果Optional为空，则可以使用orElse提供默认值。

   String result = optional.map(String::toUpperCase)
       .orElse("DEFAULT");
   

3. 使用filter进行条件过滤:
   filter方法可以用来检查Optional中的值是否满足特定条件。

   Optional<String> filtered = optional.filter(s -> s.length() > 5);
   

4. 使用ifPresent执行操作:
   如果Optional中有值，ifPresent执行一个操作。

   optional.ifPresent(System.out::println);
   

5. 使用stream方法:
   Optional类有一个stream方法，可以将Optional转换为Stream，这样就可以使用Stream API进行进一步处理。

   optional.stream()
       .map(String::toUpperCase)
       .forEach(System.out::println);