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

java自定义对象唯一性：深入理解equals与hashcode

本文旨在探讨在Java中实现自定义对象唯一性的核心机制。我们将通过一个具体的PointType类示例，详细分析equals()和hashCode()方法的正确实现方式及其在HashSet和Stream.distinct()等场景中的重要性，以确保基于对象属性而非内存地址的唯一性判断能够正确生效。

在Java开发中，我们经常需要处理包含自定义对象的集合，并从中筛选出唯一的元素。直观上，许多开发者会想到使用HashSet或Stream API中的distinct()方法。然而，当对象的唯一性判断需要基于其内部属性而非简单的对象引用时，仅凭默认的实现往往无法达到预期效果。本文将以一个PointType类为例，深入剖析这一问题，并提供一套健壮的解决方案。

问题的提出：自定义对象唯一性的挑战

假设我们有一个表示二维坐标点的PointType类，其包含x和y两个double类型属性。我们希望当两个PointType对象的x和y值都相同时，它们被认为是相等的，从而在集合中只保留一个实例。

以下是初始的PointType类及其equals方法实现：

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实例，其中p1和p2表示相同的坐标(1.0, 2.0)，p3和p4表示相同的坐标(2.0, 2.0)。我们尝试使用HashSet和Stream.distinct()来获取唯一元素：

立即学习“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 UniquenessTest {

    @Test
    public void testUniqueness() {
        Set<PointType> setA = new HashSet<>();
        Set<PointType> setB = new HashSet<>();
        ArrayList<PointType> listA = new ArrayList<>();
        ArrayList<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.toCollection(ArrayList::new));

        listB.add(p1);
        listB.add(p2);
        listB.add(p3);
        listB.add(p4);
        listB = listB.stream().distinct().collect(Collectors.toCollection(ArrayList::new));

        assertTrue(p1.equals(p2));     // 通过 (因为equals被重写)
        assertTrue(p3.equals(p4));     // 通过 (因为equals被重写)
        assertTrue(setA.size() == 1);  // 失败！预期1，实际2 (p1和p2虽然equals，但hashCode不同)
        assertTrue(setB.size() == 2);  // 失败！预期2，实际4
        assertTrue(listA.size() == 1); // 失败！预期1，实际2
        assertTrue(listB.size() == 2); // 失败！预期2，实际4
    }
}

登录后复制

上述测试结果表明，尽管我们重写了equals方法，但HashSet和Stream.distinct()并未如预期般工作。这揭示了Java中自定义对象唯一性判断的关键——equals()和hashCode()方法必须协同工作，并遵循其严格的契约。

解决方案：正确实现equals与hashCode

要使自定义对象在集合中实现基于属性的唯一性，我们需要正确地重写equals()和hashCode()方法。

1. 完善equals()方法

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

类型检查不严谨：other instanceof PointType 仅检查类型兼容性，而未检查具体类是否相同。更严谨的做法是使用getClass() != o.getClass()。
double类型比较：直接使用==比较double类型存在浮点数精度问题。虽然在简单示例中可能不明显，但在实际应用中应避免。推荐使用Double.compare()。
空值检查：缺少对other为null的检查。

以下是更健壮的equals方法实现：

WeShop唯象

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

113

查看详情

@Override
public boolean equals(Object o) {
    // 1. 引用同一对象，直接返回true
    if (this == o) return true;
    // 2. 检查o是否为null或类型不匹配
    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;
}

登录后复制

2. 实现hashCode()方法

这是解决问题的关键。Java的Object类规定，如果两个对象通过equals()方法比较为相等，那么它们的hashCode()方法必须产生相同的整数结果。反之则不要求。HashSet和HashMap等基于哈希的集合类在存储和查找元素时，会首先使用hashCode()来确定对象的存储桶位置，然后再使用equals()进行精确比较。如果hashCode()不一致，即使equals()返回true，集合也可能认为它们是不同的对象。

一个好的hashCode实现应满足以下条件：

一致性：如果对象没有被修改，多次调用hashCode()应返回相同的值。
与equals的契约：如果a.equals(b)为true，则a.hashCode() == b.hashCode()必须为true。
效率：计算hashCode应尽可能快。
分布性：对于不相等的对象，hashCode应尽可能产生不同的值，以减少哈希冲突。

我们可以使用Objects.hash()辅助方法来方便地生成hashCode，它会根据传入的属性值生成一个哈希码。

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

@Override
public int hashCode() {
    return Objects.hash(x, y); // 根据x和y属性生成哈希码
}

登录后复制

3. 完整的PointType类

结合上述修改，PointType类的完整实现如下：

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

    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() {
        return Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return "PointType{" +
               "x=" + x +
               ", y=" + y +
               '}';
    }
}

登录后复制

验证解决方案

现在，当我们使用更新后的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 UniquenessTest {

    @Test
    public void testUniqueness() {
        Set<PointType> setA = new HashSet<>();
        Set<PointType> setB = new HashSet<>();
        ArrayList<PointType> listA = new ArrayList<>();
        ArrayList<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 equals且hashCode相同，不会被添加
        setA.add(p1);
        setA.add(p2);
        assertTrue(setA.size() == 1); // 通过！

        setB.add(p1);
        setB.add(p2); // p2与p1重复
        setB.add(p3);
        setB.add(p4); // p4与p3重复
        assertTrue(setB.size() == 2); // 通过！ (包含(1.0,2.0)和(2.0,2.0)各一个)

        listA.add(p1);
        listA.add(p2);
        listA.add(p1);
        listA.add(p2);
        listA = listA.stream().distinct().collect(Collectors.toCollection(ArrayList::new));
        assertTrue(listA.size() == 1); // 通过！ (Stream.distinct()依赖于equals和hashCode)

        listB.add(p1);
        listB.add(p2);
        listB.add(p3);
        listB.add(p4);
        listB = listB.stream().distinct().collect(Collectors.toCollection(ArrayList::new));
        assertTrue(listB.size() == 2); // 通过！
    }
}

登录后复制

现在，HashSet和Stream.distinct()都能正确识别出具有相同x和y属性的PointType对象为同一个逻辑实体，并只保留一个。

总结与最佳实践

equals()与hashCode()的契约：在Java中，当您重写equals()方法时，必须同时重写hashCode()方法。这是Java集合框架（尤其是基于哈希的集合，如HashSet、HashMap）正常工作的基本要求。违反此契约会导致不可预测的行为，如重复元素被错误地添加到Set中，或Map无法正确检索值。
equals()的实现原则：
- 自反性 (Reflexivity)：x.equals(x) 必须为 true。
- 对称性 (Symmetry)：如果 x.equals(y) 为 true，那么 y.equals(x) 也必须为 true。
- 传递性 (Transitivity)：如果 x.equals(y) 为 true 且 y.equals(z) 为 true，那么 x.equals(z) 也必须为 true。
- 一致性 (Consistency)：如果对象没有被修改，多次调用 x.equals(y) 应该返回相同的结果。
- 非空性 (Non-nullity)：x.equals(null) 必须为 false。
hashCode()的实现原则：
- 在应用程序执行期间，如果对同一对象多次调用 hashCode 方法，则必须始终返回相同的整数，前提是对象中用于 equals 比较的信息没有被修改。
- 如果两个对象通过 equals(Object) 方法比较是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
- 如果两个对象通过 equals(Object) 方法比较是不相等的，不要求对这两个对象中的每个对象调用 hashCode 方法都必须生成不同的整数结果。然而，为不相等的对象生成不同的整数结果可以提高哈希表的性能。
浮点数比较：对于double或float类型的属性，应使用Double.compare()或Float.compare()进行比较，以避免浮点数精度问题导致的错误判断。
IDE辅助生成：大多数现代IDE（如IntelliJ IDEA, Eclipse）都提供了自动生成equals()和hashCode()方法的功能，强烈推荐使用它们来确保正确性和遵循最佳实践。