Java自定义对象唯一性：深入理解与正确实现equals和hashCode-java教程-PHP中文网

java自定义对象唯一性：深入理解与正确实现equals和hashcode

本文旨在探讨Java中处理自定义对象唯一性的核心机制。当使用HashSet或Stream.distinct()等集合和流操作时，若要基于对象属性而非内存地址判断唯一性，必须正确重写equals()和hashCode()方法。文章将详细阐述这两个方法的规范实现，包括处理浮点数比较和确保两者之间的一致性，并通过示例代码演示如何有效解决自定义对象去重问题。

理解Java中对象的唯一性

在Java中，判断两个对象是否“相等”有两种主要方式：

引用相等性 (Reference Equality)：使用==运算符，判断两个引用是否指向内存中的同一个对象实例。
逻辑相等性 (Logical Equality)：通过equals()方法判断。默认情况下，Object类的equals()方法也只比较引用相等性。

当我们需要在集合（如HashSet）或流操作（如Stream.distinct()）中基于对象的内容来判断唯一性时，就必须重写equals()方法。然而，仅仅重写equals()是不够的，还需要同时重写hashCode()方法，以确保这些机制能够正常工作。

考虑以下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) {
        if (other instanceof PointType && this.x == ((PointType) other).x && this.y == ((PointType) other).y) {
            return true;
        }
        return false;
    }
    // 缺少 hashCode 方法
}

登录后复制

在使用上述PointType类进行去重操作时，例如：

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

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 UniquePointTest {

    @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);
        setB.add(p1);
        setB.add(p2);
        setB.add(p3);
        setB.add(p4);

        // 尝试使用Stream.distinct()去重
        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);  // 通过，因为p1和p2是同一组逻辑相等对象
        assertTrue(setB.size() == 2);  // 失败！预期是2，实际可能是4
        assertTrue(listA.size() == 1); // 通过
        assertTrue(listB.size() == 2); // 失败！预期是2，实际可能是4
    }
}

登录后复制

上述测试中，setB.size()和listB.size()的断言会失败。这是因为HashSet和Stream.distinct()（其内部实现通常依赖于哈希表）在判断对象唯一性时，不仅会调用equals()方法，还会依赖hashCode()方法。如果hashCode()没有被正确重写，或者与equals()不一致，它们将无法正确识别逻辑上相等的对象。

equals()与hashCode()的契约与正确实现

Java规范对equals()和hashCode()方法有明确的契约要求：

自反性 (Reflexive)：对于任何非null的引用值x，x.equals(x)必须返回true。
对称性 (Symmetric)：对于任何非null的引用值x和y，当且仅当y.equals(x)返回true时，x.equals(y)才返回true。
传递性 (Transitive)：对于任何非null的引用值x、y和z，如果x.equals(y)返回true，并且y.equals(z)返回true，那么x.equals(z)必须返回true。
一致性 (Consistent)：对于任何非null的引用值x和y，只要equals()比较中使用的信息没有被修改，多次调用x.equals(y)始终返回true或始终返回false。
与null的比较：对于任何非null的引用值x，x.equals(null)必须返回false。

最关键的是equals()和hashCode()之间的一致性契约：

如果两个对象根据equals(Object)方法是相等的，那么在每个对象上调用hashCode()方法都必须产生相同的整数结果。
如果两个对象根据equals(Object)方法是不相等的，那么在每个对象上调用hashCode()方法产生不同的整数结果是不要求的。然而，为了提高哈希表的性能，不相等的对象拥有不同的哈希码会更好。

1. 修正equals()方法

原equals方法存在一些不足，尤其是直接使用==比较double类型可能导致精度问题，并且缺乏对null和类型不匹配的严格检查。一个更健壮的equals实现应遵循以下模式：

WeShop唯象

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

113

查看详情

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

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

    @Override
    public boolean equals(Object o) {
        // 1. 引用相等性检查：如果两者是同一个对象，直接返回true
        if (this == o) return true;
        // 2. null检查和类型检查：如果o为null或类型不匹配，返回false
        if (o == null || getClass() != o.getClass()) return false;
        // 3. 类型转换
        PointType pointType = (PointType) o;
        // 4. 属性比较：对于double类型，使用Double.compare()进行安全的比较
        return Double.compare(pointType.x, x) == 0 &&
               Double.compare(pointType.y, y) == 0;
    }

    // 暂时省略 hashCode
}

登录后复制

说明：

this == o：这是最快的检查，如果两个引用指向同一个对象，它们当然是相等的。
o == null || getClass() != o.getClass()：确保o不是null，并且o的运行时类型与当前对象的运行时类型完全相同。instanceof也可以用于类型检查，但getClass() != o.getClass()更严格，通常在实现equals时推荐使用。
Double.compare(pointType.x, x) == 0：这是比较两个double值的推荐方式。它能正确处理NaN、正负零等特殊浮点数值，避免了==运算符可能带来的不精确性。

2. 实现hashCode()方法

hashCode()的实现必须与equals()保持一致。如果两个PointType对象根据其x和y坐标是相等的，那么它们的hashCode也必须相同。Java 7引入的Objects.hash()方法提供了一种简洁且安全的方式来生成哈希码：

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;
    }

    @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);
    }
}

登录后复制

说明：

Objects.hash(x, y)：这个静态方法会为传入的所有参数生成一个高质量的哈希码。它会自动处理基本类型和对象类型，并确保生成的哈希码与equals方法所依赖的字段保持一致。

验证修正后的PointType类

现在，使用修正后的PointType类重新运行之前的测试：

// ... (PointType类已如上所示修正)

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 UniquePointTest {

    @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);

        setA.add(p1);
        setA.add(p2); // p2与p1逻辑相等，HashSet会将其视为重复元素
        setB.add(p1);
        setB.add(p2); // p2与p1逻辑相等
        setB.add(p3);
        setB.add(p4); // p4与p3逻辑相等

        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现在只包含一个元素 (p1)
        assertTrue(setB.size() == 2);  // 通过，setB现在包含两个元素 (p1, p3)
        assertTrue(listA.size() == 1); // 通过
        assertTrue(listB.size() == 2); // 通过
    }
}

登录后复制

现在所有的断言都将通过。这表明通过正确实现equals()和hashCode()方法，HashSet和Stream.distinct()能够准确地识别基于对象内容定义的唯一性。

注意事项与最佳实践

永远同时重写equals()和hashCode()：这是最核心的规则。只重写一个会导致不可预测的行为，尤其是在使用哈希表（HashMap、HashSet）时。
IDE的帮助：现代IDE（如IntelliJ IDEA、Eclipse）都提供了自动生成equals()和hashCode()方法的强大功能。强烈建议利用这些工具来生成初始模板，然后根据具体需求进行微调，以确保正确性和一致性。
浮点数比较：对于float和double类型，直接使用==进行比较可能不准确。应使用Float.compare()或Double.compare()，或者在某些业务场景下，考虑定义一个小的误差范围（epsilon）进行比较。
可变对象：如果一个对象在被放入哈希集合（如HashSet）后，其参与equals()和hashCode()计算的字段被修改，那么该对象的哈希码可能会改变，导致它在哈希集合中“丢失”，无法被正确查找或移除。因此，建议将用于equals()和hashCode()的字段设计为不可变的，或者至少在对象作为哈希集合的键时，避免修改这些字段。
性能考量：hashCode()方法应该尽可能高效，因为哈希码的计算频率很高。Objects.hash()通常能提供良好的性能和哈希码分布。

总结

在Java中处理自定义对象的唯一性是一个常见而重要的任务。其关键在于正确地重写equals()和hashCode()方法，并严格遵循它们之间的契约。通过规范地实现这两个方法，我们可以确保HashSet、HashMap以及Stream.distinct()等集合和流操作能够准确地识别和处理逻辑上相等的对象，从而构建出健壮且行为符合预期的Java应用程序。

以上就是Java自定义对象唯一性：深入理解与正确实现equals和hashCode的详细内容，更多请关注php中文网其它相关文章！