Collectors 详解

安晴晚风

已于 2024-07-13 15:11:47 修改

阅读量383

点赞数 13

分类专栏：后端开发文章标签： java 后端

于 2024-07-13 14:34:42 首次发布

本文链接：https://blog.csdn.net/m0_53140426/article/details/140397620

版权

后端开发专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java 8 引入的 Collectors 类是一个工具类，提供了一系列预定义的收集器实现，用于简化流（Stream）的收集操作。它具有以下优势：简化和统一了收集操作，提高了代码的可读性。Collectors 常用的静态方法包括将元素收集到集合（如 List、Set）、转换为其他类型（如 Map）、进行聚合元素操作（如计数、求和、平均值）、查找最大值和最小值、分组、分区以及连接字符串等。通过这些方法，可以轻松实现复杂的流处理逻辑，大大提高了开发效率。

前置知识：Stream API

可参考 Stream API 详解和25道练习题-CSDN博客

一、什么是 Collectors

Collectors 是 Java 8 及更高版本中引入的一个工具类，它提供了许多静态方法，这些方法返回实现了 Collector 接口的实例。Collector 接口定义了如何将流（Stream）中的元素累积成一个结果容器，这个结果容器可以是任何最终结果类型，例如一个集合、一个值或者一个映射。

二、Collectors 的优势

简化和统一了收集操作：在 Java 8 之前，将流（Stream）中的元素收集到集合或执行其他终端操作需要编写大量的样板代码。Collectors 提供了预定义的收集器，使得这些操作变得简单和统一。
提高了代码的可读性：使用 Collectors 可以用一行代码替换原本需要多行代码的收集逻辑，这使得代码更加简洁和易于理解。

三、Collectors 常用的静态方法

// 将元素收集到集合中

Collectors.toList()
Collectors.toSet()
Collectors.toCollection(Supplier<Collection<? super T>> collectionFactory)

// 转换为其他类型

Collectors.toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
Collectors.toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction)
Collectors.toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction, Supplier<M> mapSupplier)
Collectors.toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
Collectors.toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction)
Collectors.toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction, Supplier<M> mapSupplier)
Collectors.collectingAndThen(Collector<T, A, R> downstream, Function<R,RR> finisher)

// 聚合元素

Collectors.counting()
Collectors.summingInt(ToIntFunction<? super T> mapper)
Collectors.summingLong(ToLongFunction<? super T> mapper)
Collectors.summingDouble(ToDoubleFunction<? super T> mapper)
Collectors.averagingInt(ToIntFunction<? super T> mapper)
Collectors.averagingLong(ToLongFunction<? super T> mapper)
Collectors.averagingDouble(ToDoubleFunction<? super T> mapper)
Collectors.reducing(T identity, BinaryOperator<T> accumulator)
Collectors.reducing(BinaryOperator<T> accumulator)
Collectors.reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator accumulator)

// 最大值、最小值

Collectors.maxBy(Comparator<? super T> comparator)
Collectors.minBy(Comparator<? super T> comparator)

// 分组

Collectors.groupingBy(Function<? super T, ? extends K> classifier)
Collectors.groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
Collectors.groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)

// 分区

Collectors.partitioningBy(Predicate<? super T> predicate)
Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)

// 连接字符串

Collectors.joining()
Collectors.joining(CharSequence delimiter)
Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

1. 将元素收集到集合中

import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("a", "b", "c", "a", "b", "c");

        // 收集到List
        List<String> list = strings.stream().collect(Collectors.toList());
        //List<String> list = new ArrayList<>(strings);
        
        System.out.println(list);//[a, b, c, a, b, c]

        // 收集到Set
        Set<String> set = strings.stream().collect(Collectors.toSet());
        //Set<String> set = new HashSet<>(strings);
        System.out.println(set);//[a, b, c]

        // 收集到指定的集合类型，如ArrayList, LinkList, HashSet, TreeSet, PriorityQueue等
        ArrayList<String> arrayList = strings.stream().collect(Collectors.toCollection(ArrayList::new));
        //ArrayList<String> arrayList = new ArrayList<>(strings);
        System.out.println(arrayList);//[a, b, c, a, b, c]
    }
}

2. 转换为其他类型

（1）Collectors.toMap

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

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 25),
                new Person("Bob", 30),
                new Person("Charlie", 35)
        );

        Map<String, Integer> map = people.stream()
                .collect(Collectors.toMap(
                        person -> person.getName(),  // 键映射器
                        person -> person.getAge()    // 值映射器
                ));

        System.out.println(map); // 输出：{Bob=30, Alice=25, Charlie=35}

        // people.add(new Person("Charlie", 33));   // 再插入重复的键会抛出异常
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

（2）Collectors.toMap 有合并函数

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

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 25),
                new Person("Alice", 30),
                new Person("Alice", 35)
        ); // 注意有相同的名字

        Map<String, Integer> map = people.stream()
                .collect(Collectors.toMap(
                        Person::getName,            // 键映射器
                        Person::getAge,             // 值映射器
                        (age1, age2) -> age1 + age2 // 合并函数，遇到重复的键则合并
                ));

        System.out.println(map); // 输出：{Alice=55}
    }
}


class Person {
    // 同上...
}

（3）Collectors.toMap 有合并函数和映射供应器

import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Person> people = List.of(
                new Person("David", 20),
                new Person("Alice", 25),
                new Person("Alice", 35),
                new Person("Bob", 30)
        );

        Map<String, Integer> map = people.stream()
                .collect(Collectors.toMap(
                        Person::getName, // 键映射器
                        Person::getAge,  // 值映射器
                        (existingValue, newValue) -> existingValue, // 合并函数，这里选择保留旧值
                        TreeMap::new     // 映射供应器，这里使用 TreeMap 来保持键的顺序
                ));

        System.out.println(map); // 输出：{Alice=25, Bob=30, David=20} 字母序递增
    }
}

class Person {
    // 同上...
}

（4）Collectors.toConcurrentMap

Collectors.toConcurrentMap：

线程安全：生成的 ConcurrentMap 设计用于在多线程环境中使用，它提供了足够的线程安全性和并发性能。
默认映射供应器：如果没有提供特定的映射供应器，则默认使用 ConcurrentHashMap。

Collectors.toMap：

非线程安全：生成的Map在多线程环境中可能会遇到并发修改问题。
默认映射供应器：如果没有提供特定的映射供应器，则默认使用 HashMap。

以下为Collectors.toConcurrentMap的简单示例，Collectors.toConcurrentMap 有合并函数和映射供应器参考上面的（2）和（3）。

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 25),
                new Person("Bob", 30)
        );

        ConcurrentMap<String, Integer> concurrentMap = people.stream()
                .collect(Collectors.toConcurrentMap(Person::getName, Person::getAge));

        System.out.println(concurrentMap); // {Bob=30, Alice=25}
    }
}

class Person {
    // 同上...
}

（5）Collectors.collectingAndThen

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 25),
                new Person("Bob", 30),
                new Person("Charlie", 35)
        );

        // 使用 collectingAndThen 来收集名字到一个列表，然后对其进行排序
        List<String> sortedNames = people.stream()
                .map(Person::getName) // 将 Person 对象映射到它们的名字
                .collect(Collectors.collectingAndThen(
                        Collectors.toList(), // 下游收集器，先将名字收集到列表中
                        list -> {            // 然后执行排序操作
                            list.sort(String::compareTo); // 完成函数，对列表进行排序
                            return list;
                        }
                ));

        System.out.println(sortedNames); // 输出：[Alice, Bob, Charlie]
    }
}
class Person {
    // 同上...
}