自定义对象唯一性的挑战
当我们在java中操作集合或使用流api来去重时，常常会遇到一个问题：即使我们认为两个自定义对象在逻辑上是相同的（例如，它们的所有属性值都相等），但它们却被集合或流api视为不同的对象。这通常发生在尝试使用 hashset 存储自定义对象或对自定义对象列表使用 stream().distinct() 方法时。
考虑一个 PointType 类，它有两个 double 类型的坐标 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() 方法
}在上述代码中，尽管我们尝试重写 equals 方法来比较 x 和 y 属性，但将其放入 HashSet 或通过 distinct() 处理时，仍然可能无法正确识别具有相同 x 和 y 值的不同 PointType 实例为唯一对象。这是因为Java的集合框架和流API在判断对象相等性时，不仅仅依赖于 equals() 方法，对于哈希相关的操作（如 HashSet 和 distinct()），hashCode() 方法也扮演着至关重要的角色。
正确实现 equals() 方法
equals() 方法定义了两个对象在逻辑上是否相等。Java规范对 equals() 方法有严格的契约要求：
- 自反性 (Reflexive)：对于任何非空引用 x，x.equals(x) 必须返回 true。
- 对称性 (Symmetric)：对于任何非空引用 x 和 y，如果 x.equals(y) 返回 true，则 y.equals(x) 也必须返回 true。
- 传递性 (Transitive)：对于任何非空引用 x、y 和 z，如果 x.equals(y) 返回 true 且 y.equals(z) 返回 true，则 x.equals(z) 也必须返回 true。
- 一致性 (Consistent)：对于任何非空引用 x 和 y，在 equals 比较中使用的信息没有被修改的情况下，多次调用 x.equals(y) 始终返回 true 或始终返回 false。
- 非空性 (Non-nullity)：对于任何非空引用 x，x.equals(null) 必须返回 false。
针对 PointType 类，一个更健壮的 equals() 实现应该遵循以下步骤：
立即学习“Java免费学习笔记（深入）”；
@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;
}初始 equals 方法的不足在于：
- 它使用了 instanceof 而不是 getClass()，这在某些继承场景下可能导致对称性问题。
- 更重要的是，直接使用 this.x == other.x 来比较 double 类型存在精度风险。Double.compare(d1, d2) 会更安全地处理 NaN 和正负零等特殊情况。
正确实现 hashCode() 方法
hashCode() 方法返回对象的哈希码，它是一个整数值。这个方法主要用于哈希表（如 HashMap、HashSet）中，以提高查找效率。hashCode() 方法也有其严格的契约：
- 一致性 (Consistent)：在应用程序执行期间，只要对象的 equals 比较中使用的信息没有被修改，对同一对象多次调用 hashCode() 方法必须始终返回相同的整数。
- equals() 和 hashCode() 的契约：如果两个对象根据 equals(Object) 方法是相等的，那么对这两个对象中的每一个调用 hashCode() 方法都必须产生相同的整数结果。
- 不相等对象的 hashCode()：如果两个对象根据 equals(Object) 方法是不相等的，那么对这两个对象中的每一个调用 hashCode() 方法不要求产生不同的整数结果。但是，为不相等的对象生成不同的哈希码可以提高哈希表的性能。
equals() 和 hashCode() 必须同时正确实现，否则哈希集合（如 HashSet）和依赖哈希码的流操作（如 distinct()）将无法正常工作。如果两个对象 equals 返回 true 但 hashCode 不同，那么它们在哈希表中可能被存储在不同的位置，导致无法被正确识别为同一个对象。
针对 PointType 类，一个简单的 hashCode() 实现可以使用 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() 自动为所有关键属性生成哈希码
return Objects.hash(x, y);
}
}Objects.hash() 是一个非常方便的工具，它会为传入的所有参数生成一个合理的哈希码，并自动处理基本类型和 null 值。
实际应用：验证唯一性
一旦 PointType 类正确地实现了 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 setA = new HashSet<>();
Set setB = new HashSet<>();
List listA = new ArrayList<>();
List 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); // 应该通过
}
} 在 PointType 正确实现 equals() 和 hashCode() 后，上述所有的 assertTrue 断言都将成功通过。这证明了 HashSet 和 Stream.distinct() 现在能够根据我们自定义的逻辑相等性来正确地识别和处理对象的唯一性。
最佳实践与注意事项
- 始终成对实现：覆盖 equals() 方法时，几乎总是需要同时覆盖 hashCode() 方法。这是Java语言规范中的一个基本约定。
- 一致性：equals() 和 hashCode() 方法中使用的字段必须保持一致。如果 equals() 方法比较了某个字段，那么 hashCode() 方法也必须包含该字段的哈希值计算。
- 性能考量：hashCode() 方法应尽可能高效地计算哈希值，因为它可能在哈希集合中被频繁调用。Objects.hash() 提供了一个平衡性能和正确性的便捷方式。
- 不可变性：如果将对象存储在哈希集合中，并且其 equals() 和 hashCode() 所依赖的字段是可变的，那么在对象被添加到集合之后修改这些字段，可能会导致该对象在集合中无法被正确查找或删除。因此，推荐用于哈希集合的自定义对象是不可变的，或者至少其影响 equals() 和 hashCode() 的字段是不可变的。
- 浮点数比较：再次强调，对于 double 或 float 类型的比较，使用 Double.compare() 或 Float.compare() 比直接使用 == 更安全和准确，因为它能正确处理 NaN 和正负零。
- IDE辅助：现代IDE（如IntelliJ IDEA、Eclipse）通常提供自动生成 equals() 和 hashCode() 方法的功能，这可以大大减少出错的可能性，并确保遵循最佳实践。
总结
在Java中处理自定义对象的唯一性是常见的需求，而 equals() 和 hashCode() 方法是实现这一目标的核心。理解它们的契约，并按照最佳实践正确实现这两个方法，不仅能确保 HashSet 和 Stream.distinct() 等集合和流操作的正确性，还能提高程序的健壮性和可维护性。正确地管理自定义对象的相等性，是构建高效且可靠Java应用程序的关键一步。
