在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 setA = new HashSet<>();
Set setB = new HashSet<>();
ArrayList listA = new ArrayList<>();
ArrayList 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方法实现：
@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 setA = new HashSet<>();
Set setB = new HashSet<>();
ArrayList listA = new ArrayList<>();
ArrayList 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()方法的功能，强烈推荐使用它们来确保正确性和遵循最佳实践。
通过正确理解和实现equals()和hashCode()，我们可以确保Java集合框架能够准确无误地处理自定义对象的唯一性，从而构建更健壮、可预测的应用程序。
