在日常开发中，我们经常遇到需要对对象列表去重的场景——比如从数据库查询出重复数据、批量导入时过滤重复记录，或者合并多个数据源时剔除重复对象。Java 8的Stream API提供了distinct()方法，一句代码就能实现去重，但很多小伙伴在处理自定义对象时却频频踩坑：明明属性相同的对象，用distinct()就是去不掉！今天就带大家彻底搞懂自定义对象去重的底层逻辑，结合equals()和hashCode()的最佳实践，让你写出既简洁又高效的去重代码！

一、为什么distinct()对自定义对象"失效"？

先看一个经典反例：定义一个Person类，包含id和name属性，当我们用Stream.distinct()对List<Person>去重时，明明id相同的对象却被当成不同元素保留了下来——这是为什么？

// 错误示例：未重写equals和hashCode
class Person {
    private String id;
    private String name;

    // 省略构造器和getter/setter
}

public class Test {
    public static void main(String[] args) {
        List<Person> list = Arrays.asList(
            new Person("1", "张三"),
            new Person("1", "张三"), // id相同，理应去重
            new Person("2", "李四")
        );

        // 去重后依然有3个元素！
        long count = list.stream().distinct().count();
        System.out.println(count); // 输出结果：3 
    }
}

关键原因：distinct()的底层依赖

distinct()方法的去重逻辑并非比较对象内容，而是依赖equals()和hashCode()方法。默认情况下，这两个方法继承自Object类：

• equals()：比较对象内存地址（类似==）
• hashCode()：返回对象内存地址的哈希值

因此，即使两个Person对象的id和name完全相同，只要是不同的对象实例，distinct()就会认为它们是不同元素，导致去重失败。

二、核心解决方案：重写equals()和hashCode()

要让distinct()正确识别自定义对象的重复，必须同时重写equals()和hashCode()，并遵循以下契约：

1. 一致性：对象属性不变时，多次调用hashCode()返回值相同
2. 等价性：若a.equals(b) == true，则a.hashCode() == b.hashCode()
3. 非等价性：若a.equals(b) == false，hashCode()尽量不同（提升哈希表性能）

步骤1：定义实体类并重写方法

以Person类为例，假设我们需要根据id去重（id是唯一标识），代码如下：

import java.util.Objects;

class Person {
    private String id; // 唯一标识，用于去重
    private String name;

    // 构造器、getter/setter省略

    // 重写equals：根据id判断是否相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true; // 同一对象直接返回true
        if (o == null || getClass() != o.getClass()) return false; // 类型不同返回false
        Person person = (Person) o;
        return Objects.equals(id, person.id); // 比较id是否相同
    }

    // 重写hashCode：基于id生成哈希值
    @Override
    public int hashCode() {
        return Objects.hash(id); // 使用Objects.hash简化哈希计算
    }
}

步骤2：使用Stream.distinct()去重

重写后，distinct()就能正确识别重复对象：

public class Test {
    public static void main(String[] args) {
        List<Person> list = Arrays.asList(
            new Person("1", "张三"),
            new Person("1", "张三"), // 重复对象，会被去重
            new Person("2", "李四")
        );

        // 去重后只剩2个元素
        List<Person> uniqueList = list.stream()
                .distinct()
                .collect(Collectors.toList());

        System.out.println(uniqueList.size()); // 输出结果：2 
    }
}

代码运行效果：通过重写equals和hashCode，distinct()成功去除重复对象

三、3种进阶去重方法：灵活应对复杂场景

除了distinct()，实际开发中还会遇到无法修改实体类（如第三方库对象）或需要按部分属性去重的场景，这时可以用以下3种方法：

方法1：基于单个属性去重（Collectors.toMap）

适用于根据某个唯一属性（如id）去重，且需保留首个出现元素的场景：

List<Person> list = Arrays.asList(
    new Person("1", "张三"),
    new Person("1", "张三"),
    new Person("2", "李四")
);

// 以id为key，冲突时保留已有元素
List<Person> uniqueList = list.stream()
    .collect(Collectors.toMap(
        Person::getId,  // key：id（去重依据）
        p -> p,         // value：对象本身
        (existing, replacement) -> existing // 冲突处理：保留前者
    ))
    .values() // 提取value集合
    .stream()
    .collect(Collectors.toList());

方法2：基于多属性去重（TreeSet自定义比较器）

当需要根据多个属性（如id+name）去重时，可使用TreeSet搭配比较器：

List<Person> list = Arrays.asList(
    new Person("1", "张三"),
    new Person("1", "张三"), // id+name相同，去重
    new Person("1", "张小三") // id相同但name不同，保留
);

// 按id+name组合属性去重
List<Person> uniqueList = list.stream()
    .collect(Collectors.toCollection(
        () -> new TreeSet<>(
            Comparator.comparing(p -> p.getId() + p.getName()) // 组合属性
        )
    ))
    .stream()
    .collect(Collectors.toList());

方法3：动态条件去重（filter+ConcurrentHashMap）

需动态指定去重规则（如保留最后出现的元素）时，用filter配合线程安全的集合：

List<Person> list = Arrays.asList(
    new Person("1", "张三"),
    new Person("1", "张三"), // 重复，保留后者
    new Person("2", "李四")
);

// 线程安全的Set记录已出现的id
Set<String> seenIds = ConcurrentHashMap.newKeySet();

// 保留最后出现的重复元素
List<Person> uniqueList = list.stream()
    .filter(p -> seenIds.add(p.getId())) // add返回false表示重复
    .collect(Collectors.toList());

四、避坑指南：常见问题与解决方案

HashSet去重流程图：先通过hashCode定位，再用equals比较，两者缺一不可

五、实战案例：电商订单数据去重

场景：批量导入订单数据时，需根据orderId去重，避免重复入库。
实现：定义Order类并重写equals和hashCode，使用Stream.distinct()去重。

class Order {
    private String orderId; // 订单唯一标识
    private String product;
    private BigDecimal amount;

    // 重写equals和hashCode（基于orderId）
    @Override
    public boolean equals(Object o) { /* 实现略 */ }
    @Override
    public int hashCode() { /* 实现略 */ }
}

// 批量导入去重
List<Order> orders = importFromExcel(); // 从Excel读取订单
List<Order> uniqueOrders = orders.stream()
    .distinct()
    .collect(Collectors.toList());
db.batchInsert(uniqueOrders); // 入库去重后的订单

案例来源：CSDN博客《java使用Stream流对自定义对象数组去重的实现》

六、最佳实践

1. 优先使用distinct()：简单场景下，重写equals和hashCode后直接调用，代码最简洁。
2. 灵活选择工具方法：无法修改实体类用toMap/TreeSet，动态规则用filter+Set。
3. 重视性能优化：大数据集去重时，预排序减少哈希冲突，并行流用ConcurrentHashMap。

掌握这些技巧，不仅能解决日常开发中的去重问题，更能深入理解Java集合框架的底层逻辑。快去试试用Stream API优化你的去重代码吧！如果觉得有用，记得点赞收藏哦～