实现自定义Deque的equals方法：深度比较与性能优化

package deque;

import java.util.Iterator;
import java.util.Objects; // 导入 Objects 类，用于安全比较可能为 null 的对象

public class ArrayDeque implements Deque, Iterable {
    private T[] ts;
    private int size;
    private int stposition;
    private int firposition;
    private int lastposition;

    public ArrayDeque() {
        ts = (T[]) new Object[8];
        size = 0;
        stposition = Math.round(ts.length / 2);
        firposition = stposition;
        lastposition = stposition;
    }

    // 假设 get() 和 size() 方法已正确实现
    public T get(int i) {
        if (size <= i || i < 0) { // 修正边界条件
            return null;
        }
        int pos = (firposition + i) % ts.length;
        return ts[pos];
    }

    public int size() {
        return size;
    }

    @Override
    public Iterator iterator() {
        return new ArrayDequeIterator();
    }

    // 内部迭代器类，必须正确实现 hasNext() 和 next()
    private class ArrayDequeIterator implements Iterator {
        private int currentCount = 0; // 记录已遍历的元素数量
        private int currentPos = firposition; // 从 firposition 开始遍历

        @Override
        public boolean hasNext() {
            return currentCount < size;
        }

        @Override
        public T next() {
            if (!hasNext()) {
                throw new java.util.NoSuchElementException();
            }
            T item = ts[currentPos];
            currentPos = (currentPos + 1) % ts.length;
            currentCount++;
            return item;
        }
    }

    @Override
    public boolean equals(Object o) {
        // 1. 引用相等性检查
        if (o == this) {
            return true;
        }
        // 2. 空值检查
        if (o == null) {
            return false;
        }
        // 3. 类型兼容性检查
        // 注意：这里使用 instanceof Deque 确保可以转换为 Deque 接口
        if (!(o instanceof Deque)) {
            return false;
        }

        // 4. 类型转换
        // 使用泛型通配符  提高兼容性
        Deque<?> otherDeque = (Deque<?>) o;

        // 5. 大小检查
        if (this.size() != otherDeque.size()) {
            return false;
        }

        // 6. 元素逐一比较（使用迭代器进行高效遍历）
        // 确保 this (ArrayDeque) 和 otherDeque (可能是其他 Deque 实现) 都能被迭代
        Iterator thisIterator = this.iterator();
        // 假设 otherDeque 也实现了 Iterable 或可以通过某种方式获取迭代器
        // 如果 otherDeque 无法直接获取迭代器，且其 get(i) 性能已知为 O(1)，则可以考虑使用 get(i)
        // 但对于通用的 Deque 接口，通常推荐迭代器。
        // 为了示例的通用性，我们假设 otherDeque 也有一个迭代器。
        // 如果 Deque 接口没有继承 Iterable，则需要依赖 get(i)
        // 针对原始问题中的 ArrayDeque 和 LinkedListArrayDeque，它们通常会实现 Iterable。
        // 如果 Deque 接口本身不要求 Iterable，则应回退到 get(i) 方式。
        // 考虑到 ArrayDeque 实现了 Iterable，这里使用迭代器。
        // 如果 otherDeque 也是 ArrayDeque，则可以获取其迭代器。
        // 如果 otherDeque 是 LinkedListArrayDeque，也应该有迭代器。
        // 因此，这里假设 otherDeque 也是 Iterable。
        // 如果 Deque 接口没有继承 Iterable，并且我们只能通过 get(i) 访问 otherDeque，
        // 则需要这样写：
        // for (int i = 0; i < this.size(); i++) {
        //     Object element1 = this.get(i);
        //     Object element2 = otherDeque.get