Java API

Stream流

流收集合

//流转化为集合
Stream<String> stream = Stream.of("A", "B", "C");
stream.collect(Collectors.toList())
stream.collect(Collectors.toSet())
stream.collect(Collectors.toCollection(ArraysList::new))
//流转化为数组
stream.toArray()
stream.toArray(int[]::new)
//聚合计算
stream.collect(Collectors.maxBy())
stream.collect(Collectors.minBy())
stream.collect(Collectors.counting())
stream.collect(Collectors.summingInt())
stream.collect(Collectors.averagingInt())
//分组  分组函数  值收集器默认为List
stream.collect(Collectors.groupingBy())
//分区
stream.collcet(Collectors.partitionBy())
//拼接
stream.collect(Collectors.joining())

Java Stream API 提供了多种方法将流（Stream）转换为不同的集合类型、数组，以及进行聚合计算和复杂的数据操作。以下是一些常用的 Stream 操作的总结，包括代码示例和注释：

1. 流转换为集合

• List

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

  将流收集到一个列表中。

• Set

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

  将流收集到一个集合中，自动去除重复元素。

• Map

Map<String, Fruit> fruitMap = fruits.stream()
   	.collect(Collectors.toMap(Fruit::getName, fruit -> fruit));

• 自定义集合

  Collection<String> collection = stream.collect(Collectors.toCollection(ArrayList::new));

  将流收集到一个由提供 Supplier 函数指定的集合中。

2. 流转换为数组

• Object 数组

  Object[] array = stream.toArray();

  将流转换为 Object 数组。

• 特定类型数组

  int[] intArray = stream.mapToInt(String::length).toArray();

  将流转换为特定类型的数组，需要流的中间操作以确定数组的类型。

3. 聚合计算

• 最大值

  Optional<String> max = stream.collect(Collectors.maxBy(Comparator.naturalOrder()));

  找出流中的最大元素。

• 最小值

  Optional<String> min = stream.collect(Collectors.minBy(Comparator.naturalOrder()));

  找出流中的最小元素。

• 计数

  long count = stream.collect(Collectors.counting());

  计算流中元素的数量。

• 求和

  int sum = stream.collect(Collectors.summingInt(String::length));

  对流中的元素进行求和，适用于数字类型的流。

• 平均值

  double average = stream.collect(Collectors.averagingInt(String::length));

  计算流中元素的平均值。

4. 分组

• GroupingBy

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

  按元素的某种属性将流分组。

5. 分区

• PartitionBy

  Map<Boolean, List<String>> partitioned = stream.collect(Collectors.partitioningBy(s -> s.startsWith("A")));

  根据谓词将流分为两部分。

6. 拼接

• Joining

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

  将流中的元素拼接成一个字符串。

注意事项

• 每个 collect 操作都会消费流，因此一个流只能进行一次终端操作，除非使用 peek 或者 forEach 进行中间操作。
• toArray 方法有几个重载版本，可以创建任何对象类型或原始类型的数组。
• Collectors 类提供了多种收集器，可以进行复杂的数据转换和聚合操作。
• 一些操作如 groupingBy 和 partitioningBy 可以与 downstream 结合使用，以对分组或分区后的流进行进一步的收集操作。

示例

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        // 创建一个字符串列表
        List<String> words = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");

        // filter + forEach：过滤出长度大于4的单词，并打印出来
        words.stream()
             .filter(word -> word.length() > 4)
             .forEach(System.out::println);

        // map + collect：将所有单词转换为大写，并收集到一个新的列表中
        List<String> uppercasedWords = words.stream()
                                             .map(String::toUpperCase)
                                             .collect(Collectors.toList());

        // limit + sorted：获取按字典序排序后前3个单词
        List<String> firstThreeSorted = words.stream()
                                             .sorted()
                                             .limit(3)
                                             .collect(Collectors.toList());

        // reduce：使用 reduce 方法找到最长的单词
        Optional<String> longestWord = words.stream()
                                              .reduce((w1, w2) -> w1.length() >= w2.length() ? w1 : w2);

        // allMatch + anyMatch + noneMatch：检查单词长度
        boolean allLong = words.stream()
                               .allMatch(word -> word.length() > 4); // 检查所有单词是否都大于4个字符
        boolean anyLong = words.stream()
                               .anyMatch(word -> word.length() > 4); // 检查是否有单词大于4个字符
        boolean noneLong = words.stream()
                                .noneMatch(word -> word.length() > 4); // 检查没有单词大于4个字符

        // count：计算单词的数量
        long wordCount = words.stream().count();

        // max + min：找出最长和最短的单词
        Optional<String> maxWord = words.stream().max(byLength());
        Optional<String> minWord = words.stream().min(byLength());

        // distinct：去除重复的单词
        List<String> distinctWords = words.stream()
                                           .distinct()
                                           .collect(Collectors.toList());

        // parallel：创建并行流处理数据
        int parallelSum = Arrays.stream(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
                               .parallel()
                               .sum();
    }

    // 辅助方法，用于按长度比较单词
    private static Comparator<String> byLength() {
        return (s1, s2) -> Integer.compare(s1.length(), s2.length());
    }
}