在Java编程中，当我们创建自定义的集合类（例如本文中的ArrayDeque或LinkedListArrayDeque）时，正确地重写Object类中的equals方法至关重要。默认的equals方法仅比较两个对象的内存地址，即它们是否是同一个实例。然而，对于集合而言，我们通常期望比较它们是否在逻辑上相等，即它们包含的元素是否相同且顺序一致。
理解equals方法的重要性
重写equals方法是为了让自定义对象能够进行有意义的逻辑相等性比较。对于集合类，这意味着判断两个集合是否包含相同的元素，并且这些元素在集合中的排列顺序也相同。如果未正确重写，即使两个集合包含完全相同的元素，它们在equals比较时也会被认为是不同的对象，这在很多场景下都不是我们期望的行为。
equals方法的基本契约
在重写equals方法时，必须遵守Object类定义的以下五个基本契约：
- 自反性 (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)始终返回相同的结果。
- 与null的比较：对于任何非null的引用值x，x.equals(null)必须返回false。
实现自定义Deque的equals方法
针对自定义的Deque集合，实现equals方法的核心在于逐一比较两个集合中的所有元素。
立即学习“Java免费学习笔记（深入）”；
核心逻辑与“深度比较”的误区
许多开发者在初次实现集合的equals方法时，可能会考虑引入一个独立的deepEquals方法来处理集合内部元素的比较。然而，这通常是一个误解。Java的equals方法设计理念是，每个对象都应该知道如何判断自己与另一个对象是否相等。因此，当比较集合中的元素时，我们应该直接调用元素自身的equals方法。如果集合的元素本身是另一个集合（例如Deque>），那么内层集合的equals方法会递归地处理其元素的比较，从而自然地实现了“深度比较”的效果。我们自定义的Deque的equals方法只需要负责遍历并调用元素的equals方法即可。
基础结构
一个健壮的equals方法通常从以下几个基础检查开始：
@Override
public boolean equals(Object o) {
// 1. 自反性：与自身比较，始终返回true
if (o == this) {
return true;
}
// 2. 与null比较，以及类型检查：如果o为null或不是Deque类型，则返回false
// 注意：这里使用Deque<?>是为了更好地处理泛型，确保类型兼容性
if (o == null || !(o instanceof Deque)) {
return false;
}
// 3. 类型转换：将Object o转换为Deque类型
Deque<?> otherDeque = (Deque<?>) o;
// 4. 大小比较：如果两个Deque的大小不同，则它们不可能相等
if (otherDeque.size() != this.size()) {
return false;
}
// ... 接下来是元素逐一比较的逻辑
return true; // 占位符，实际逻辑在此处实现
}元素逐一比较：迭代器的优势
在进行元素逐一比较时，性能是一个重要的考量因素。
使用get(index)方法的潜在问题：
如果Deque的底层实现（如LinkedListArrayDeque）的get(index)方法是O(N)复杂度（例如，对于链表实现），那么在一个循环中反复调用get(index)将导致整个equals方法的复杂度变为O(N^2)，这在处理大型集合时会非常低效。
// 示例：使用get(index)进行比较（不推荐用于O(N)的get实现）
// ... (前置检查代码)
for (int i = 0; i < this.size(); i++) {
Object element1 = this.get(i);
Object element2 = otherDeque.get(i); // 如果otherDeque.get(i)是O(N)，则整体O(N^2)
// 使用Objects.equals进行null安全比较
if (!Objects.equals(element1, element2)) {
return false;
}
}
return true;使用迭代器实现高效比较：
为了避免O(N^2)的性能问题，最佳实践是使用迭代器（Iterator）进行元素遍历。迭代器通常提供O(1)的平均时间复杂度来访问下一个元素，从而使整个equals方法的复杂度保持在O(N)。
// 示例：使用迭代器进行比较（推荐）
// ... (前置检查代码)
// 获取两个Deque的迭代器
Iterator<T> thisIterator = this.iterator(); // 假设ArrayDeque实现了Iterable<T>
Iterator<?> otherIterator = otherDeque.iterator();
// 逐一比较元素，直到其中一个迭代器没有更多元素
while (thisIterator.hasNext() && otherIterator.hasNext()) {
T element1 = thisIterator.next();
Object element2 = otherIterator.next();
// 使用Objects.equals进行null安全比较，并依赖元素自身的equals方法
if (!Objects.equals(element1, element2)) {
return false;
}
}
// 由于之前已经检查了size是否相等，所以循环结束后，两个迭代器应该同时耗尽。
// 如果循环结束但其中一个还有元素（这在size检查后不应该发生），则表示逻辑错误。
return true;健壮性考量：空值处理与Objects.equals
在比较元素时，处理null值是一个常见的陷阱。直接使用element1.equals(element2)可能会在element1为null时抛出NullPointerException。Java 7引入的java.util.Objects.equals(Object a, Object b)方法提供了一个空值安全的比较方式：
- 如果a和b都为null，返回true。
- 如果a为null，b不为null，返回false。
- 如果a不为null，b为null，返回false。
- 如果a和b都不为null，则调用a.equals(b)。
因此，强烈推荐使用Objects.equals(element1, element2)来代替手动进行null检查和equals调用。
不推荐的类类型检查
在某些equals实现中，可能会看到类似a1.getClass() != a2.getClass()的检查。这种检查通常过于严格，并且可能违反equals的对称性或传递性契约。例如，ArrayList和LinkedList如果包含相同的元素，它们在逻辑上应该是相等的，即使它们的运行时类不同。equals方法应该关注对象的逻辑状态，而不是其精确的运行时类型。让元素自身的equals方法处理其内部逻辑，通常会避免这种问题。
完整且优化的equals方法示例
结合上述最佳实践，以下是为ArrayDeque
import java.util.Iterator;
import java.util.Objects; // 引入Objects类，提供null-safe的equals方法
// 假设 Deque 接口和 ArrayDeque 类定义如下
interface Deque<T> extends Iterable<T> { // Deque接口应继承Iterable
int size();
// 其他 Deque 方法...
}
public class ArrayDeque<T> implements Deque<T> {
private T[] ts;
private int size;
private int firposition; // 队列头部索引
private int lastposition; // 队列尾部索引
public ArrayDeque() {
ts = (T[]) new Object[8];
size = 0;
firposition = ts.length / 2;
lastposition = ts.length / 2;
}
// 假设get方法和iterator方法已正确实现
public T get(int i) {
if (i < 0 || i >= size) {
return null; // 或者抛出IndexOutOfBoundsException
}
int actualIndex = (firposition + i) % ts.length;
return ts[actualIndex];
}
@Override
public int size() {
return size;
}
@Override
public Iterator<T> iterator() {
return new ArrayDequeIterator();
}
private class ArrayDequeIterator implements Iterator<T> {
private int currentPosition = firposition;
private int count = 0; // 记录已遍历的元素数量
@Override
public boolean hasNext() {
return count < size;
}
@Override
public T next() {
if (!hasNext()) {
throw new java.util.NoSuchElementException();
}
T item = ts[currentPosition];
currentPosition = (currentPosition + 1) % ts.length;
count++;
return item;
}
}
@Override
public boolean equals(Object o) {
// 1. 自反性
if (o == this) {
return true;
}
// 2. null检查和类型检查
// 使用 instanceof 判断是否是 Deque 类型，而不是具体的 ArrayDeque 类型
// 这样可以实现与 LinkedListArrayDeque 等其他 Deque 实现的比较
if (o == null || !(o instanceof Deque)) {
return false;
}
// 3. 类型转换
// 使用 Deque<?> 来兼容不同泛型参数的 Deque 实例
Deque<?> otherDeque = (Deque<?>) o;
// 4. 大小比较
if (otherDeque.size() != this.size()) {
return false;
}
// 5. 元素逐一比较：使用迭代器提高性能
Iterator<T> thisIterator = this.iterator();
Iterator<?> otherIterator = otherDeque.iterator();
while (thisIterator.hasNext()) { // 循环条件只需检查一个迭代器，因为大小已确定相等
T element1 = thisIterator.next();
Object element2 = otherIterator.next(); // otherDeque可能持有不同类型的元素
// 使用 Objects.equals 进行 null-safe 比较
// 这会调用 element1.equals(element2)，如果 element1 为 null 则直接返回 false
if (!Objects.equals(element1, element2)) {
return false;
}
}
// 所有元素都相等，且大小相同
return true;
}
}注意事项
- 重写hashCode方法：根据Java约定，如果重写了equals方法，就必须同时重写hashCode方法。equals相等的对象必须具有相同的hashCode值。否则，在使用基于哈希的集合（如HashMap、HashSet）时，可能会出现严重的错误。
- Deque接口应继承Iterable：为了能够使用增强型for循环（for (final Object a1 : this)）或直接获取迭代器，Deque接口必须继承java.lang.Iterable接口，并提供iterator()
