在java开发中，我们经常需要处理包含自定义对象的集合，并从中筛选出唯一的元素。直观上，我们可能会尝试使用hashset或stream api中的distinct()方法。然而，当这些方法未能按照预期工作时，问题往往指向自定义对象中equals()和hashcode()方法的实现。本文将通过一个具体的pointtype类示例，详细解析这一常见问题及其解决方案。
理解自定义对象的唯一性
Java集合框架中的许多类（如HashSet、HashMap）以及Stream API的distinct()操作，都依赖于对象的equals()和hashCode()方法来判断对象的逻辑相等性。
- equals()方法：定义了两个对象在逻辑上是否相等。默认的equals()方法（来自Object类）比较的是对象的内存地址（即this == other），这通常不是我们期望的自定义对象相等性。
- hashCode()方法：为对象生成一个整数哈希码。对于哈希表（如HashSet），它首先通过哈希码快速定位可能的相等对象，然后才调用equals()方法进行精确比较。
当我们需要根据对象的属性（而不是它们的内存地址）来判断唯一性时，就必须正确地重写这两个方法。
PointType类示例与问题分析
假设我们有一个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) {
// 这里的比较存在缺陷，且缺少hashCode()的配合
if (other instanceof PointType && this.x == ((PointType) other).x && this.y == ((PointType) other).y) {
return true;
}
return false;
}
// 缺少hashCode()方法
// ...
}在上述代码中，我们尝试重写equals方法来比较x和y属性。然而，当使用HashSet或Stream.distinct()进行去重时，可能会发现结果不符合预期。例如：
立即学习“Java免费学习笔记（深入）”；
import org.junit.jupiter.api.Test; // 假设使用JUnit 5
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
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());
assertTrue(p1.equals(p2)); // 通过 (因为equals被重写了)
assertTrue(p3.equals(p4)); // 通过
assertTrue(setA.size() == 1); // 失败！预期为1，实际为2 (因为p1和p2哈希码不同)
assertTrue(setB.size() == 2); // 失败！预期为2，实际为4 (因为p1,p2,p3,p4哈希码都不同)
assertTrue(listA.size() == 1); // 失败！预期为1，实际为2
assertTrue(listB.size() == 2); // 失败！预期为2，实际为4
}
} 上述测试结果表明，尽管p1.equals(p2)通过了，但HashSet和Stream.distinct()未能正确识别逻辑上相等的对象。这是因为HashSet和distinct()不仅依赖于equals()，还高度依赖于hashCode()方法。
正确重写equals()和hashCode()
要解决上述问题，我们需要对PointType类进行两项关键改进：
1. 完善equals()方法
原始的equals方法存在两个小问题：
- 对null和不同类型对象的处理不够严谨。
- 直接使用==比较double类型的值可能存在浮点数精度问题。虽然对于精确匹配的字面量可能有效，但在实际计算中，浮点数比较应使用Double.compare()。
一个更健壮的equals()实现应遵循以下约定：
- 自反性：x.equals(x) 必须为 true。
- 对称性：如果 x.equals(y) 为 true，那么 y.equals(x) 也必须为 true。
- 传递性：如果 x.equals(y) 为 true 且 y.equals(z) 为 true，那么 x.equals(z) 也必须为 true。
- 一致性：如果对象没有被修改，多次调用 x.equals(y) 应该返回相同的结果。
- 与 null 的比较：x.equals(null) 必须为 false。
修正后的equals()方法：
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;
}
// Getter方法 (可选，但通常推荐)
public double getX() { return x; }
public double getY() { return y; }
@Override
public boolean equals(Object o) {
// 1. 内存地址相同，直接返回true
if (this == o) return true;
// 2. o为null或类型不一致，直接返回false
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;
}
// ... 稍后添加hashCode()
}getClass() != o.getClass() 确保了只有当两个对象的运行时类型完全相同时才可能相等。这比 instanceof 更严格，更适用于某些场景。Double.compare(double d1, double d2) 是比较两个double值的推荐方式，它能正确处理NaN、正负零等特殊情况。
2. 实现hashCode()方法
当且仅当equals()方法被重写时，hashCode()方法也必须被重写。 这是Java中一个非常重要的契约。如果两个对象根据equals()方法是相等的，那么它们的hashCode()方法必须产生相同的整数结果。反之则不要求，即不同的对象可以有相同的哈希码（哈希冲突），但哈希码相同不代表对象一定相等。
一个糟糕的hashCode()实现（例如，总是返回一个常数）会导致哈希表性能急剧下降，因为它将所有对象都放入同一个“桶”中，退化为链表操作。一个好的hashCode()实现应该：
- 为相等的对象返回相同的哈希码。
- 为不相等的对象返回不同的哈希码，以减少哈希冲突。
Java 7 引入的 java.util.Objects 工具类提供了 Objects.hash() 方法，可以方便地生成基于多个字段的哈希码，强烈推荐使用。
修正后的hashCode()方法：
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;
}
// Getter方法
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() {
// 使用Objects.hash()方法生成哈希码，基于所有参与equals比较的字段
return Objects.hash(x, y);
}
}验证解决方案
现在，有了正确实现的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);
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.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只有一个元素
assertTrue(setB.size() == 2); // 通过！现在setB只有两个元素
assertTrue(listA.size() == 1); // 通过！
assertTrue(listB.size() == 2); // 通过！
}
} 所有测试现在都将通过。这证明了正确重写equals()和hashCode()方法对于自定义对象在哈希集合和Stream.distinct()操作中实现逻辑唯一性至关重要。
注意事项与最佳实践
- equals()和hashCode()的契约：务必遵守“如果两个对象相等（根据equals()），则它们的哈希码必须相等（根据hashCode()）”这一核心契约。
- 选择参与比较的字段：equals()和hashCode()方法应该基于对象中所有用于定义逻辑相等性的字段。对于PointType，就是x和y。
- 浮点数比较：对于float和double类型，应使用Float.compare()和Double.compare()进行比较，而不是直接使用==。
- Objects工具类：充分利用java.util.Objects类提供的Objects.equals()和Objects.hash()方法，它们能简化代码并减少出错的可能性。
- 不变性：如果对象会被用作HashMap的键或HashSet的元素，强烈建议使其成为不可变对象。这意味着一旦对象被创建，其用于equals()和hashCode()计算的字段就不能再改变。如果可变对象在被放入集合后其关键字段发生改变，那么在集合中查找或删除该对象将变得困难甚至不可能。
- 性能考虑：一个高效的hashCode()实现能够将哈希冲突降到最低，从而提高哈希集合的性能。Objects.hash()通常提供了一个合理的默认实现。
总结
在Java中处理自定义对象的唯一性问题时，仅仅重写equals()方法是不够的。为了确保HashSet、HashMap以及Stream.distinct()等机制能正确识别逻辑上相等的对象，我们必须同时并正确地重写equals()和hashCode()方法。遵循Java的equals和hashCode契约，并利用现代Java API（如Objects.hash()和Double.compare()），可以构建健壮且高效的自定义对象相等性判断逻辑。
