Java中自定义对象唯一性判断与集合去重-java教程-PHP中文网

Java中自定义对象唯一性判断与集合去重

本文深入探讨了在Java中对自定义对象进行唯一性判断和集合去重的关键机制。通过一个PointType类的实例，详细阐述了正确重写equals()和hashCode()方法的必要性及其实现细节，特别强调了它们在HashSet和Stream.distinct()等场景中的作用，以确保基于对象属性而非内存地址的逻辑唯一性。

在java开发中，我们经常需要处理包含自定义对象的集合，并从中筛选出唯一的元素。直观上，我们可能会尝试使用hashset或stream api中的distinct()方法。然而，当这些方法未能按照预期工作时，问题往往指向自定义对象中equals()和hashcode()方法的实现。本文将通过一个具体的pointtype类示例，详细解析这一常见问题及其解决方案。

理解自定义对象的唯一性

Java集合框架中的许多类（如HashSet、HashMap）以及Stream API的distinct()操作，都依赖于对象的equals()和hashCode()方法来判断对象的逻辑相等性。

equals()方法：定义了两个对象在逻辑上是否相等。默认的equals()方法（来自Object类）比较的是对象的内存地址（即this == other），这通常不是我们期望的自定义对象相等性。
hashCode()方法：为对象生成一个整数哈希码。对于哈希表（如HashSet），它首先通过哈希码快速定位可能的相等对象，然后才调用equals()方法进行精确比较。

当我们需要根据对象的属性（而不是它们的内存地址）来判断唯一性时，就必须正确地重写这两个方法。

PointType类示例与问题分析

假设我们有一个PointType类，表示一个二维点，包含x和y两个双精度浮点数属性：

public class PointType {
    private double x;
    private double y;

    public PointType(double x, double y) {
        this.x = x;
        this.y = y;
    }

    // 初始尝试的equals方法
    @Override
    public boolean equals(Object other) {
        // 这里的比较存在缺陷，且缺少hashCode()的配合
        if (other instanceof PointType && this.x == ((PointType) other).x && this.y == ((PointType) other).y) {
            return true;
        }
        return false;
    }

    // 缺少hashCode()方法
    // ...
}

登录后复制

在上述代码中，我们尝试重写equals方法来比较x和y属性。然而，当使用HashSet或Stream.distinct()进行去重时，可能会发现结果不符合预期。例如：

立即学习“Java免费学习笔记（深入）”；

import org.junit.jupiter.api.Test; // 假设使用JUnit 5
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import static org.junit.jupiter.api.Assertions.assertTrue;

public class PointTypeUniquenessTest {

    @Test
    public void testUniqueness() {
        Set<PointType> setA = new HashSet<>();
        Set<PointType> setB = new HashSet<>();
        List<PointType> listA = new ArrayList<>();
        List<PointType> listB = new ArrayList<>();

        PointType p1 = new PointType(1.0, 2.0);
        PointType p2 = new PointType(1.0, 2.0); // 逻辑上与p1相等
        PointType p3 = new PointType(2.0, 2.0);
        PointType p4 = new PointType(2.0, 2.0); // 逻辑上与p3相等

        // 尝试使用HashSet
        setA.add(p1);
        setA.add(p2);
        setA.add(p1);
        setA.add(p2);

        setB.add(p1);
        setB.add(p2);
        setB.add(p3);
        setB.add(p4);

        // 尝试使用ArrayList和Stream
        listA.add(p1);
        listA.add(p2);
        listA.add(p1);
        listA.add(p2);
        listA = listA.stream().distinct().collect(Collectors.toList());

        listB.add(p1);
        listB.add(p2);
        listB.add(p3);
        listB.add(p4);
        listB = listB.stream().distinct().collect(Collectors.toList());

        assertTrue(p1.equals(p2));     // 通过 (因为equals被重写了)
        assertTrue(p3.equals(p4));     // 通过

        assertTrue(setA.size() == 1);  // 失败！预期为1，实际为2 (因为p1和p2哈希码不同)
        assertTrue(setB.size() == 2);  // 失败！预期为2，实际为4 (因为p1,p2,p3,p4哈希码都不同)

        assertTrue(listA.size() == 1); // 失败！预期为1，实际为2
        assertTrue(listB.size() == 2); // 失败！预期为2，实际为4
    }
}

登录后复制

上述测试结果表明，尽管p1.equals(p2)通过了，但HashSet和Stream.distinct()未能正确识别逻辑上相等的对象。这是因为HashSet和distinct()不仅依赖于equals()，还高度依赖于hashCode()方法。

正确重写equals()和hashCode()

要解决上述问题，我们需要对PointType类进行两项关键改进：

1. 完善equals()方法

原始的equals方法存在两个小问题：

对null和不同类型对象的处理不够严谨。
直接使用==比较double类型的值可能存在浮点数精度问题。虽然对于精确匹配的字面量可能有效，但在实际计算中，浮点数比较应使用Double.compare()。

一个更健壮的equals()实现应遵循以下约定：

自反性：x.equals(x) 必须为 true。
对称性：如果 x.equals(y) 为 true，那么 y.equals(x) 也必须为 true。
传递性：如果 x.equals(y) 为 true 且 y.equals(z) 为 true，那么 x.equals(z) 也必须为 true。
一致性：如果对象没有被修改，多次调用 x.equals(y) 应该返回相同的结果。
与 null 的比较：x.equals(null) 必须为 false。

修正后的equals()方法：

WeShop唯象

WeShop唯象是国内首款AI商拍工具，专注电商产品图片的智能生成。

113

查看详情

import java.util.Objects; // 导入Objects工具类

public class PointType {
    private double x;
    private double y;

    public PointType(double x, double y) {
        this.x = x;
        this.y = y;
    }

    // Getter方法 (可选，但通常推荐)
    public double getX() { return x; }
    public double getY() { return y; }

    @Override
    public boolean equals(Object o) {
        // 1. 内存地址相同，直接返回true
        if (this == o) return true;
        // 2. o为null或类型不一致，直接返回false
        if (o == null || getClass() != o.getClass()) return false;
        // 3. 类型转换
        PointType pointType = (PointType) o;
        // 4. 比较关键属性，使用Double.compare处理浮点数比较
        return Double.compare(pointType.x, x) == 0 &&
               Double.compare(pointType.y, y) == 0;
    }

    // ... 稍后添加hashCode()
}

登录后复制

getClass() != o.getClass() 确保了只有当两个对象的运行时类型完全相同时才可能相等。这比 instanceof 更严格，更适用于某些场景。Double.compare(double d1, double d2) 是比较两个double值的推荐方式，它能正确处理NaN、正负零等特殊情况。

2. 实现hashCode()方法

当且仅当equals()方法被重写时，hashCode()方法也必须被重写。 这是Java中一个非常重要的契约。如果两个对象根据equals()方法是相等的，那么它们的hashCode()方法必须产生相同的整数结果。反之则不要求，即不同的对象可以有相同的哈希码（哈希冲突），但哈希码相同不代表对象一定相等。

一个糟糕的hashCode()实现（例如，总是返回一个常数）会导致哈希表性能急剧下降，因为它将所有对象都放入同一个“桶”中，退化为链表操作。一个好的hashCode()实现应该：

为相等的对象返回相同的哈希码。
为不相等的对象返回不同的哈希码，以减少哈希冲突。

Java 7 引入的 java.util.Objects 工具类提供了 Objects.hash() 方法，可以方便地生成基于多个字段的哈希码，强烈推荐使用。

修正后的hashCode()方法：

import java.util.Objects;

public class PointType {
    private double x;
    private double y;

    public PointType(double x, double y) {
        this.x = x;
        this.y = y;
    }

    // Getter方法
    public double getX() { return x; }
    public double getY() { return y; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PointType pointType = (PointType) o;
        return Double.compare(pointType.x, x) == 0 &&
               Double.compare(pointType.y, y) == 0;
    }

    @Override
    public int hashCode() {
        // 使用Objects.hash()方法生成哈希码，基于所有参与equals比较的字段
        return Objects.hash(x, y);
    }
}

登录后复制

验证解决方案

现在，有了正确实现的equals()和hashCode()方法，我们再次运行之前的测试：

import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import static org.junit.jupiter.api.Assertions.assertTrue;

public class PointTypeUniquenessTest {

    @Test
    public void testUniqueness() {
        Set<PointType> setA = new HashSet<>();
        Set<PointType> setB = new HashSet<>();
        List<PointType> listA = new ArrayList<>();
        List<PointType> listB = new ArrayList<>();

        PointType p1 = new PointType(1.0, 2.0);
        PointType p2 = new PointType(1.0, 2.0);
        PointType p3 = new PointType(2.0, 2.0);
        PointType p4 = new PointType(2.0, 2.0);

        // 使用HashSet
        setA.add(p1);
        setA.add(p2);
        setA.add(p1);
        setA.add(p2);

        setB.add(p1);
        setB.add(p2);
        setB.add(p3);
        setB.add(p4);

        // 使用ArrayList和Stream
        listA.add(p1);
        listA.add(p2);
        listA.add(p1);
        listA.add(p2);
        listA = listA.stream().distinct().collect(Collectors.toList());

        listB.add(p1);
        listB.add(p2);
        listB.add(p3);
        listB.add(p4);
        listB = listB.stream().distinct().collect(Collectors.toList());

        assertTrue(p1.equals(p2));     // 通过
        assertTrue(p3.equals(p4));     // 通过
        assertTrue(setA.size() == 1);  // 通过！现在setA只有一个元素
        assertTrue(setB.size() == 2);  // 通过！现在setB只有两个元素
        assertTrue(listA.size() == 1); // 通过！
        assertTrue(listB.size() == 2); // 通过！
    }
}

登录后复制

所有测试现在都将通过。这证明了正确重写equals()和hashCode()方法对于自定义对象在哈希集合和Stream.distinct()操作中实现逻辑唯一性至关重要。

注意事项与最佳实践

equals()和hashCode()的契约：务必遵守“如果两个对象相等（根据equals()），则它们的哈希码必须相等（根据hashCode()）”这一核心契约。
选择参与比较的字段：equals()和hashCode()方法应该基于对象中所有用于定义逻辑相等性的字段。对于PointType，就是x和y。
浮点数比较：对于float和double类型，应使用Float.compare()和Double.compare()进行比较，而不是直接使用==。
Objects工具类：充分利用java.util.Objects类提供的Objects.equals()和Objects.hash()方法，它们能简化代码并减少出错的可能性。
不变性：如果对象会被用作HashMap的键或HashSet的元素，强烈建议使其成为不可变对象。这意味着一旦对象被创建，其用于equals()和hashCode()计算的字段就不能再改变。如果可变对象在被放入集合后其关键字段发生改变，那么在集合中查找或删除该对象将变得困难甚至不可能。
性能考虑：一个高效的hashCode()实现能够将哈希冲突降到最低，从而提高哈希集合的性能。Objects.hash()通常提供了一个合理的默认实现。

总结

在Java中处理自定义对象的唯一性问题时，仅仅重写equals()方法是不够的。为了确保HashSet、HashMap以及Stream.distinct()等机制能正确识别逻辑上相等的对象，我们必须同时并正确地重写equals()和hashCode()方法。遵循Java的equals和hashCode契约，并利用现代Java API（如Objects.hash()和Double.compare()），可以构建健壮且高效的自定义对象相等性判断逻辑。

以上就是Java中自定义对象唯一性判断与集合去重的详细内容，更多请关注php中文网其它相关文章！