如何利用Collectors.toSet实现流中变量的自动去重收集并优化性能

在Java的Stream流操作中，Collectors.toSet是实现元素去重收集的常用工具方法，它会自动将流中的元素收集到一个Set集合中，利用Set集合不允许重复元素的特性完成去重。该方法使用简单，不需要开发者手动编写去重逻辑，能大幅减少代码量。

Collectors.toSet基础用法演示

Collectors.toSet的使用非常直接，只需要将其作为Stream的collect方法的参数即可，下面是一个简单的字符串去重示例：

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class ToSetDemo {
    public static void main(String[] args) {
        // 包含重复元素的字符串列表
        List<String> sourceList = List.of("apple", "banana", "apple", "orange", "banana", "grape");
        // 使用Collectors.toSet去重收集
        Set<String> distinctSet = sourceList.stream().collect(Collectors.toSet());
        // 输出去重后的结果
        System.out.println(distinctSet);
    }
}

上述代码的执行结果为[banana, orange, apple, grape]，可以看到重复的元素已经被自动过滤，最终得到的Set中只包含不重复的元素。

Collectors.toSet的实现原理

查看Collectors.toSet的源码可以发现，它的核心逻辑是创建一个HashSet实例，然后将流中的每个元素依次添加到这个HashSet中，最终返回这个HashSet。其简化逻辑如下：

public static <T> Collector<T, ?, Set<T>> toSet() {
    return new CollectorImpl<>(
        HashSet::new,  // 供应器，创建空的HashSet
        Set::add,      // 累加器，将元素添加到HashSet
        (left, right) -> {     // 组合器，合并两个Set
            left.addAll(right);
            return left;
        },
        CH_UNORDERED
    );
}

由于底层使用的是HashSet，所以最终得到的Set集合是无序的，如果需要保证元素的顺序，就不能直接使用Collectors.toSet。

Collectors.toSet的性能问题分析

虽然Collectors.toSet使用便捷，但在部分场景下存在性能隐患：

• 底层默认使用HashSet，初始容量是16，负载因子是0.75。如果流中元素数量远超过初始容量，会触发多次扩容操作，扩容需要重新计算哈希值并复制元素，增加额外开销。
• 对于自定义对象，如果没有正确重写equals和hashCode方法，会导致去重失效，甚至出现不符合预期的结果。
• 在并行流场景下，组合器需要合并多个线程生成的HashSet，合并过程也会产生额外的性能消耗。

性能优化方案

1. 预指定初始容量减少扩容

如果提前知道流中元素的大致数量，可以手动创建HashSet并指定初始容量，再通过Collectors.toCollection收集到该Set中，避免频繁扩容：

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class ToSetOptimizeDemo {
    public static void main(String[] args) {
        List<String> sourceList = // 假设这里是大量元素列表
        // 预估元素数量为10000，计算初始容量：10000 / 0.75 + 1
        int expectedSize = 10000;
        Set<String> distinctSet = sourceList.stream()
                .collect(Collectors.toCollection(() -> new HashSet<>((int)(expectedSize / 0.75f) + 1)));
    }
}

2. 自定义对象正确重写equals和hashCode

如果去重的对象是自定义类型，必须根据去重的业务逻辑重写equals和hashCode方法，否则HashSet无法正确判断元素是否重复：

import java.util.Objects;

public class User {
    private Long id;
    private String name;

    // 构造器、getter、setter省略

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        // 仅根据id判断是否为同一个用户，实现按id去重
        return Objects.equals(id, user.id);
    }

    @Override
    public int hashCode() {
        // 仅使用id计算哈希值，和equals逻辑保持一致
        return Objects.hash(id);
    }
}

3. 并行流场景下的优化选择

如果使用的是并行流，并且元素数量非常大，可以考虑使用Collectors.toConcurrentMap替代Collectors.toSet，减少合并开销：

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

public class ParallelStreamOptimize {
    public static void main(String[] args) {
        List<String> sourceList = // 大量元素列表
        // 使用ConcurrentMap实现去重，键为元素本身，值为固定占位符
        Map<String, Boolean> distinctMap = sourceList.parallelStream()
                .collect(Collectors.toConcurrentMap(
                    s -> s,       // 键为元素本身
                    s -> true,    // 值固定为true
                    (a, b) -> a   // 遇到重复键时保留原有值
                ));
        // 获取去重后的键集合
        List<String> distinctList = distinctMap.keySet().stream().collect(Collectors.toList());
    }
}

不同方案的适用场景对比

下面通过表格对比不同去重收集方案的优缺点和适用场景：

注意事项

• Collectors.toSet返回的Set是不可修改的吗？答案是否定的，返回的HashSet是可修改的，可以后续调用add方法添加新元素。
• 如果需要去重后保留元素的插入顺序，可以使用Collectors.toCollection(LinkedHashSet::new)替代Collectors.toSet。
• 去重逻辑依赖元素的equals和hashCode方法，对于字符串、Integer等内置类型无需额外处理，自定义类型需要自行实现。

Collectors_toSetStream流去重收集性能优化Java集合修改时间：2026-06-11 02:42:42