Java自定义对象唯一性：深入理解 equals() 与 hashCode()

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() 方法
}

@Override
public boolean equals(Object o) {
    // 1. 自反性优化：如果对象是自身，直接返回 true
    if (this == o) return true;

    // 2. 非空性检查和类型检查：
    //    o == null 检查：如果传入对象为null，则不相等
    //    getClass() != o.getClass() 检查：确保比较的是相同运行时类型的对象
    //    (注意：有时会使用 instanceof，但 getClass() 更严格，推荐用于类层次结构扁平的情况)
    if (o == null || getClass() != o.getClass()) return false;

    // 3. 类型转换：将 Object 转换为当前类型
    PointType pointType = (PointType) o;

    // 4. 属性比较：比较所有用于定义对象逻辑相等性的关键属性
    //    对于 double 类型，直接使用 == 可能会因浮点数精度问题导致不准确。
    //    推荐使用 Double.compare() 来进行安全的浮点数比较。
    return Double.compare(pointType.x, x) == 0 &&
           Double.compare(pointType.y, y) == 0;
}

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() 自动为所有关键属性生成哈希码
        return Objects.hash(x, y);
    }
}

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); // 与 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.distinct() 验证唯一性
        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());

        // 验证 equals 方法是否正确
        assertTrue(p1.equals(p2)); // 应该通过
        assertTrue(p3.equals(p4)); // 应该通过

        // 验证 HashSet 的唯一性
        assertTrue(setA.size() == 1); // 应该通过，因为 p1 和 p2 逻辑相等
        assertTrue(setB.size() == 2); // 应该通过，因为 (p1,p2) 和 (p3,p4) 是两组逻辑相等对象

        // 验证 Stream.distinct() 的唯一性
        assertTrue(listA.size() == 1); // 应该通过
        assertTrue(listB.size() == 2); // 应该通过
    }
}