Java Stream的distinct去重原理分析_Java

一、distinct 的基础用法与核心特性

distinct()是 stream api 中的有状态中间操作，用于移除流中的重复元素，其底层依赖元素的hashcode()和equals()方法。用法示例：

list<integer> numbers = arrays.aslist(1, 2, 2, 3, 4, 4);
list<integer> unique = numbers.stream()
    .distinct()
    .collect(collectors.tolist());  // [1, 2, 3, 4]

核心特性：

去重逻辑基于元素的唯一性标识，而非内存地址；
保持元素首次出现的顺序；
属于有状态操作，处理过程中需维护已出现元素的集合。

二、distinct 的底层实现原理

1. 顺序流中的去重实现

顺序流中，distinct()通过hashset存储已处理元素，流程如下：

遍历流中的每个元素；
对每个元素计算hashcode()，检查hashset中是否存在相同哈希值的元素；
若存在，进一步通过equals()比较内容，相同则过滤；
若不存在，将元素添加到hashset并保留在流中。

源码关键片段（jdk 17）：

// referencepipeline.java
public final stream<p_out> distinct() {
    return new distinctops<p_out, p_out>(this);
}
 
// distinctops.java
@override
public void accept(p_out t) {
    if (set.add(t)) {  // 调用hashset的add方法，返回false表示重复
        down.accept(t);
    }
}

2. 并行流中的去重优化

并行流中，distinct()使用concurrenthashmap或分段处理提升性能：

将流分割为多个子任务，每个子任务维护独立的hashset；
子任务处理完成后，合并所有hashset的结果；
合并时使用hashmap去重，避免并发冲突。

并行处理示意图：

+----------------+     +----------------+     +----------------+
|  子任务1: hashset |---->|  子任务2: hashset |---->|  合并阶段: hashmap |
|  存储元素a,b,c   |     |  存储元素b,d,e   |     |  最终结果a,b,c,d,e |
+----------------+     +----------------+     +----------------+

三、去重逻辑的核心依赖：hashcode 与 equals

1. 自定义对象的去重规则

若需对自定义对象去重，必须正确重写hashcode()和equals()：

class user {
    private string id;
    private string name;
    
    @override
    public int hashcode() {
        return objects.hash(id);  // 仅用id计算哈希值
    }
    
    @override
    public boolean equals(object o) {
        if (this == o) return true;
        if (o == null || getclass() != o.getclass()) return false;
        user user = (user) o;
        return objects.equals(id, user.id);  // 仅比较id
    }
    // 其他方法省略
}
 
// 使用示例
list<user> users = arrays.aslist(
    new user("1", "alice"),
    new user("1", "bob"),  // id相同，会被去重
    new user("2", "charlie")
);
list<user> uniqueusers = users.stream()
    .distinct()
    .collect(collectors.tolist());  // 保留两个用户

2. 常见误区：仅重写 equals 不重写 hashcode

若只重写equals，会导致去重失效，因为hashset首先通过hashcode判断元素是否存在：

class erroruser {
    private string id;
    // 错误：未重写hashcode
    @override
    public boolean equals(object o) {
        // 正确实现equals...
    }
}
// 使用distinct时，两个id相同的erroruser可能因hashcode不同被视为不同元素

四、distinct 的性能影响与优化策略

1. 性能损耗的主要原因

内存占用：需存储所有已出现元素，大数据集可能导致 oom；
哈希计算开销：每个元素需计算hashcode并进行哈希表查找；
并行流的合并开销：多线程环境下的集合合并操作耗时。

2. 大数据集的去重优化

预排序 + 相邻去重：对有序流使用distinct()效率更高，因重复元素相邻时哈希表查找次数减少

// 优化前：无序流去重
list<integer> randomdata = getrandomnumbers(1000000);
randomdata.stream().distinct().count();  // 全量哈希表查找
 
// 优化后：先排序再去重
randomdata.stream()
    .sorted()
    .distinct()
    .count();  // 相邻重复元素只需一次比较

使用 primitive stream 减少装箱：

// 低效：对象流装箱
stream<integer> boxedstream = data.stream().distinct();
 
// 高效：intstream直接操作
intstream primitivestream = data.stream().maptoint(integer::intvalue).distinct();

分块处理大集合：避免一次性加载所有元素到内存

// 分块去重示例
int chunksize = 100000;
list<integer> result = new arraylist<>();
for (int i = 0; i < data.size(); i += chunksize) {
    int end = math.min(i + chunksize, data.size());
    list<integer> chunk = data.sublist(i, end);
    result.addall(chunk.stream().distinct().collect(collectors.tolist()));
}
// 最后再去重一次合并结果
list<integer> finalresult = result.stream().distinct().collect(collectors.tolist());

3. 并行流去重的参数调优

通过自定义spliterator控制分块大小，减少合并开销：

class efficientspliterator implements spliterator<integer> {
    private final list<integer> list;
    private int index;
    private static final int chunk_size = 10000;  // 分块大小
    
    public efficientspliterator(list<integer> list) {
        this.list = list;
        this.index = 0;
    }
    
    @override
    public spliterator<integer> trysplit() {
        int size = list.size() - index;
        if (size < chunk_size) return null;
        int splitpos = index + size / 2;
        spliterator<integer> spliterator = 
            new efficientspliterator(list.sublist(index, splitpos));
        index = splitpos;
        return spliterator;
    }
    // 其他方法省略...
}
 
// 使用示例
list<integer> data = ...;
stream<integer> optimizedstream = streamsupport.stream(
    new efficientspliterator(data), true);  // 启用并行

五、特殊场景的去重方案

1. 基于部分属性的去重

若需根据对象的部分属性去重（而非全部属性），可结合map和collect：

class product {
    private string id;
    private string name;
    private double price;
    // 构造器、getter省略
}
 
// 按id去重
list<product> uniqueproducts = products.stream()
    .collect(collectors.collectingandthen(
        collectors.tomap(product::getid, p -> p, (p1, p2) -> p1),
        map -> new arraylist<>(map.values())
    ));

2. 去重并保留最新元素

在日志等场景中，需按时间戳去重并保留最新记录：

class logentry {
    private string message;
    private long timestamp;
    // 构造器、getter省略
}
 
list<logentry> latestlogs = logs.stream()
    .collect(collectors.tomap(
        logentry::getmessage, 
        entry -> entry, 
        (oldentry, newentry) -> newentry.gettimestamp() > oldentry.gettimestamp() 
            ? newentry : oldentry
    ))
    .values()
    .stream()
    .collect(collectors.tolist());

3. 模糊去重（非精确匹配）

如需基于相似度去重（如字符串编辑距离），需自定义去重逻辑：

list<string> fuzzyunique = strings.stream()
    .filter(s -> !strings.stream()
        .anymatch(t -> s != t && levenshteindistance(s, t) < 2))
    .collect(collectors.tolist());

六、性能对比：distinct 与其他去重方式

去重方式	大数据集性能	内存占用	实现复杂度	适用场景
stream.distinct()	中	高（存储所有元素）	低	通用去重
先排序 + 相邻去重	高	中	中	有序数据去重
hashset 直接去重	高	高	低	简单集合去重
分块去重	高	低	高	超大数据集去重