Java Deque元素替换问题：如何基于x、y值移除指定元素

我来给你几个实用的方案，都是实际开发里常用的思路，解决你没法通过引用移除目标元素的问题：

方案1：重写Element的equals方法，用“探针”对象匹配 #

Deque.removeFirstOccurrence(Object o) 方法是通过调用对象的 equals() 来判断是否匹配的，所以我们可以重写Element的equals方法，让它只比较x和y属性，然后创建一个只设置了x、y的“探针”对象来触发移除。

首先修改Element类，重写equals和hashCode（hashCode是好习惯，避免后续用哈希集合时出问题）：

import java.util.Objects;

class Element {
    public int x;
    public int y;
    public String moves;

    @Override
    public boolean equals(Object o) {
        // 先判断是否是同一个对象
        if (this == o) return true;
        // 判空+类型检查
        if (o == null || getClass() != o.getClass()) return false;
        Element element = (Element) o;
        // 只比较x和y
        return x == element.x && y == element.y;
    }

    @Override
    public int hashCode() {
        // 用x和y生成哈希值
        return Objects.hash(x, y);
    }
}

然后在业务代码里，创建探针对象调用removeFirstOccurrence：

// 假设新的更优对象是newEle，x=3、y=3
Element probe = new Element();
probe.x = newEle.x;
probe.y = newEle.y;

// 移除队列中第一个x/y匹配的旧元素
list.removeFirstOccurrence(probe);
// 添加新对象
list.add(newEle);

这个方案代码简洁，完全利用Deque自带的方法，适合队列元素不多的场景。

方案2：手动遍历Deque，用迭代器移除匹配元素 #

如果你不想修改Element的equals逻辑（比如原本需要比较所有属性），可以直接遍历Deque，找到x/y匹配的元素后用迭代器移除（避免ConcurrentModificationException）：

// 假设新的更优对象是newEle
Iterator<Element> iterator = list.iterator();
while (iterator.hasNext()) {
    Element current = iterator.next();
    if (current.x == newEle.x && current.y == newEle.y) {
        iterator.remove();
        break; // 找到第一个匹配的就停止，和removeFirstOccurrence行为一致
    }
}
list.add(newEle);

这个方案更灵活，不影响Element类原有逻辑，缺点是需要手动遍历，元素多的时候效率稍低。

方案3：用HashMap维护坐标到元素的映射，提升效率 #

如果你的队列元素数量很大，遍历的开销太高，可以用HashMap把(x,y)坐标映射到对应的Element对象，这样可以快速定位并移除旧元素：

首先定义一个坐标类（Java 16+可以用Record，低版本用自定义类）：

// Java 16+ 推荐用Record，自动实现equals和hashCode
record Coordinate(int x, int y) {}

// 低版本Java自定义Coordinate类
/*
class Coordinate {
    private final int x;
    private final int y;

    public Coordinate(int x, int 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;
        Coordinate that = (Coordinate) o;
        return x == that.x && y == that.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}
*/

然后同时维护Deque和HashMap：

Deque<Element> list = new LinkedList<>();
Map<Coordinate, Element> coordElementMap = new HashMap<>();

// 添加新元素的逻辑
Element newEle = new Element();
newEle.x = 3;
newEle.y = 3;
newEle.moves = "更优的路径";

Coordinate key = new Coordinate(newEle.x, newEle.y);
// 先从Map中取出旧元素并移除
Element oldEle = coordElementMap.remove(key);
if (oldEle != null) {
    // 从队列中移除旧元素
    list.remove(oldEle);
}
// 添加新元素到队列和Map
list.add(newEle);
coordElementMap.put(key, newEle);

这个方案的优势是可以O(1)时间判断是否存在目标元素，避免全队列遍历，适合元素数量多、性能要求高的场景。

内容的提问来源于stack exchange，提问作者user11857971