理解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 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);
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实现应遵循以下模式：
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 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);
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应用程序。
