Java Collectors工具类

目录

1.toList

2.toSet

3.toMap

4.toCollection

5.joining

6.groupingBy

7.partitioningBy

8.mapping

9.reducing

10.averagingInt & averagingLong & averagingLong

11. summingInt & summingLong & summingDouble

12.maxBy & minBy

13.counting

14.collectingAndThen

15.toConcurrentMap

Collectors 是 Java 8 引入的一个工具类，用于提供各种常见的 Collector 实现。这些 Collector 可以用于将流中的元素收集到各种目标容器中，如 List、Set、Map 等。下面是一些 Collectors 工具类中常用的静态方法及其用法示例。

1.toList

描述：将流中的元素收集到一个 List 中。

List<String> list = Stream.of("a", "b", "c").collect(Collectors.toList());

2.toSet

描述：将流中的元素收集到一个 Set 中，去除重复项。

Set<String> set = Stream.of("a", "b", "c", "a").collect(Collectors.toSet());

3.toMap

方法一：将流转换为映射。

Map<String, Integer> nameToAge = people.stream().collect(Collectors.toMap(Person::getName, Person::getAge));

方法二：将流转换为映射，在键冲突时提供合并策略。

List<String> items = Arrays.asList("apple", "banana", "apple");
Map<String, Long> itemCounts = items.stream().collect(Collectors.toMap(Function.identity(), item -> 1L, Long::sum));
System.out.println(itemCounts); // 结果: {banana=1, apple=2}

4.toCollection

描述：将流中的元素收集到一个由工厂方法创建的集合中。

List<String> linkedList = Stream.of("a", "b", "c").collect(Collectors.toCollection(LinkedList::new));

5.joining

方法一：将流中的字符串元素连接成一个单一的字符串。

String joined = Stream.of("a", "b", "c").collect(Collectors.joining(", "));
System.out.println(joined);  // 结果: "a, b, c"

方法二：将流中的字符串元素连接成一个单一的字符串，并添加前缀和后缀。

String joined = Stream.of("a", "b", "c").collect(Collectors.joining(", ", "[", "]"));
System.out.println(joined); // 结果: "[a, b, c]"

6.groupingBy

方法一：将流中的元素按某个分类函数分组，结果是一个 Map<K, List<T>>。

Map<String, List<String>> grouped = Stream.of("apple", "banana", "cherry", "date", "cat")
                .collect(Collectors.groupingBy(s -> s.substring(0, 1)));
System.out.println(grouped); // {a=[apple], b=[banana], c=[cherry, cat], d=[date]}

方法二：将流中的元素按某个分类函数分组，并使用下游收集器进一步处理每个分组的结果。

Map<String, Set<String>> grouped = Stream.of("apple", "banana", "cherry", "date", "cherry")
                .collect(Collectors.groupingBy(s -> s.substring(0, 1), Collectors.toSet()));
System.out.println(grouped); // 结果: {a=[apple], b=[banana], c=[cherry], d=[date]}

7.partitioningBy

方法一：将流中的元素按某个谓词分为两部分，结果是一个 Map<Boolean, List<T>>。

Map<Boolean, List<Integer>> partitioned = Stream.of(1, 2, 3, 4, 5)
                .collect(Collectors.partitioningBy(i -> i % 2 == 0));
System.out.println(partitioned); // 结果: {false=[1, 3, 5], true=[2, 4]}

方法二：将流中的元素按某个谓词分为两部分，并使用下游收集器进一步处理每个部分的结果。

Map<Boolean, Set<Integer>> partitioned = Stream.of(1, 2, 3, 4, 5, 2)
                .collect(Collectors.partitioningBy(i -> i % 2 == 0, Collectors.toSet()));
System.out.println(partitioned); // 结果: {false=[1, 3, 5], true=[2, 4]}

8.mapping

描述：将流中的元素映射到另一个类型，并使用下游收集器进一步处理。

List<String> mapped = Stream.of("apple", "banana", "cherry")
                .collect(Collectors.mapping(String::toUpperCase, Collectors.toList()));
System.out.println(mapped); // 结果: ["APPLE", "BANANA", "CHERRY"]

9.reducing

方法一：将流中的元素通过二元操作符进行归约。

Optional<Integer> sum = Stream.of(1, 2, 3, 4).collect(Collectors.reducing(Integer::sum));
System.out.println(sum); // 结果: Optional[10]

方法二：将流中的元素通过二元操作符进行归约，并提供一个初始值。

int sum = Stream.of(1, 2, 3, 4, 5).collect(Collectors.reducing(2, Integer::sum));
System.out.println(sum); // 结果: // 结果: 17

方法三：将流中的元素映射到另一个类型，并通过二元操作符进行归约。

int sum = Stream.of("1", "2", "3", "4", "6").collect(Collectors.reducing(2, Integer::parseInt, Integer::sum));
System.out.println(sum); // 结果: // 结果: 18

10.averagingInt & averagingLong & averagingLong

描述：计算流中元素的平均值，元素类型分别为 int, long, double。

double average = Stream.of(1, 2, 3, 4).collect(Collectors.averagingInt(Integer::intValue));
System.out.println(average); // 结果: 2.5

double average = Stream.of(1L, 2L, 3L, 4L).collect(Collectors.averagingLong(Long::longValue));
System.out.println(average); // 结果: 2.5

double average = Stream.of(1.0, 2.0, 3.0, 4.0).collect(Collectors.averagingDouble(Double::doubleValue));
System.out.println(average); // 结果: 2.5

11. summingInt & summingLong & summingDouble

描述：计算流中元素的总和，元素类型分别为 int, long, double。

int sum = Stream.of(1, 2, 3, 4).collect(Collectors.summingInt(Integer::intValue));
System.out.println(sum); // 结果: 10

long sum = Stream.of(1L, 2L, 3L, 4L).collect(Collectors.summingLong(Long::longValue));
System.out.println(sum); // 结果: 10

double sum = Stream.of(1.0, 2.0, 3.0, 4.0).collect(Collectors.summingDouble(Double::doubleValue));
System.out.println(sum); // 结果: 10.0

12.maxBy & minBy

描述：找到流中最大值/ 最小值的元素。

Optional<Integer> max = Stream.of(1, 2, 3, 4).collect(Collectors.maxBy(Integer::compare));
System.out.println(max); // Optional[4]

Optional<Integer> min = Stream.of(1, 2, 3, 4).collect(Collectors.minBy(Integer::compare));
System.out.println(min); // Optional[1]

13.counting

描述：计算流中元素的数量。

long count = Stream.of(1, 2, 3, 4, 7).collect(Collectors.counting());
System.out.println(count); // 结果: 5

14.collectingAndThen

描述：允许你在收集结果后执行额外的操作。

List<String> words = Arrays.asList("hello", "world");
String result = words.stream().collect(Collectors.collectingAndThen(Collectors.joining(", "), str -> "Result: " + str));
System.out.println(result); // 结果: Result: hello, world

15.toConcurrentMap

描述：将流转换为并发映射（ConcurrentMap），适用于多线程环境。

List<String> keys = Arrays.asList("key1", "key2", "key3");
ConcurrentMap<String, Integer> concurrentMap = keys.stream().collect(Collectors.toConcurrentMap(Function.identity(), k -> k.length()));
System.out.println(concurrentMap); // 结果: {key1=4, key2=4, key3=4}