如何在Java中查找队列中最后出现的元素

我正在尝试查找某个字符串在 队列。我正在使用另一个队列和变量。我被困在这里，我应该使用堆栈或队列来解决这个问题，以及如何解决。 任何帮助都将不胜感激

import java.util.Stack;
import java.util.Queue;
import java.util.LinkedList;

public class StackQueue{
public static void remove(Queue<String> queue, String toRemove){
    if(queue.isEmpty()){throw new NullPointerException();}

    Queue<String> tmp = new LinkedList<>();
    Queue<String> tmp1 = new LinkedList<>();
    int count = 0;

    while(! queue.isEmpty()){
        String removed = queue.remove();        
        if(toRemove == removed){
            tmp.add(removed);
            count++;
        }
        else{
            tmp1.add(removed);
        }       
    }

    while (!tmp1.isEmpty()){
        queue.add(tmp1.remove());
    }
}
public static void main(String[] args){
    Queue<String> q = new LinkedList<>();
    q.add("a");
    q.add("e");
    q.add("b");
    q.add("a");     
    q.add("e");


    System.out.println(q);
    remove(q, "a");     
    System.out.println(q);
}
 }

import java.util.Stack；
导入java.util.Queue；
导入java.util.LinkedList；
公共类堆栈队列{
公共静态无效删除（队列、字符串删除）{
if（queue.isEmpty（））{抛出新的NullPointerException（）；}
队列tmp=newlinkedlist（）；
队列tmp1=新链接列表（）；
整数计数=0；
而（！queue.isEmpty（））{
String removed=queue.remove（）；
如果（删除==删除）{
tmp.添加（删除）；
计数++；
}
否则{
tmp1.添加（删除）；
}       
}
而（！tmp1.isEmpty（））{
queue.add（tmp1.remove（））；
}
}
公共静态void main（字符串[]args）{
队列q=新的LinkedList（）；
q、 添加（“a”）；
q、 添加（“e”）；
q、 添加（“b”）；
q、 添加（“a”）；
q、 添加（“e”）；
系统输出println（q）；
删除（q，“a”）；
系统输出println（q）；
}
}

这里有一种方法。迭代队列并将其内容转储到临时队列中（就像您正在做的那样）。跟踪要删除的元素的最后一次看到的索引。最后，遍历临时队列并将其内容转储回原始队列，忽略找到的索引处的项

public static void remove(Queue<String> queue, String toRemove) {
    Queue<String> tmp = new LinkedList<>();
    int lastFoundIdx = -1;

    for (int i = 0; !queue.isEmpty(); i++) {
        String elem = queue.poll();

        if (elem.equals(toRemove)) {
            lastFoundIdx = i;
        }

        tmp.offer(elem);
    }

    for (int i = 0; !tmp.isEmpty(); i++) {
        if (i == lastFoundIdx) {
            tmp.poll();
        }
        else {
            queue.offer(tmp.poll());
        }
    }
}

publicstaticvoidremove（队列、字符串删除）{
队列tmp=newlinkedlist（）；
int lastFoundIdx=-1；
对于（int i=0；！queue.isEmpty（）；i++）{
字符串elem=queue.poll（）；
如果（元素等于（toRemove））{
lastFoundIdx=i；
}
tmp报价（elem）；
}
对于（int i=0；！tmp.isEmpty（）；i++）{
如果（i==lastFoundIdx）{
tmp.poll（）；
}
否则{
queue.offer（tmp.poll（））；
}
}
}

A

Queue

不适合您的使用，事实上，您的类名

StackQueue

提示您可能需要一个

Deque

（尽管这可能是巧合）

Deque

（双端队列）接口指定所需的确切方法。本质上，

Deque

允许您从两端添加一个remove，这也有助于

堆栈

行为，因此如果更灵活的话，您可以从两端执行remove操作

相比之下，

队列

仅提供从队列前端的删除，或通过搜索

队列

中找到的第一个匹配项进行删除（尽管这可能取决于实现，因为在

集合

接口中指定的方法不说明它必须是第一个匹配项…）

对于您的用例，

队列

的问题在于，该接口旨在仅允许类似队列的行为，防止在不强制转换的情况下使用底层实现，从而更容易执行此类任务（例如，

LinkedList

或

ArrayDeque

）。对于这一点，强制转换是远远不可取的，如果实际实现发生了变化怎么办

如果坚持使用

队列

，则不需要创建另一个

队列

的另一个解决方案是使用队列的

迭代器

和

迭代器。remove（）

。例如：

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {

    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.add("a");
        queue.add("b");
        queue.add("c");
        queue.add("a");
        queue.add("d");
        queue.add("a");
        queue.add("b");
        System.out.println("Before: " + queue);
        remove(queue, "a");
        System.out.println("After: " + queue);
    }

    public static void remove(Queue<String> queue, String toRemove){
        int indexToRemove = findLastIndex(queue, toRemove);
        removeIndex(queue, indexToRemove);
    }

    private static int findLastIndex(Queue<String> queue, String value) {
        int indexToRemove = -1;
        int index = 0;
        for (Iterator<String> iterator = queue.iterator(); iterator.hasNext(); index++) {
            String current = iterator.next();
            if (value.equals(current)) {
                indexToRemove = index;
            }
        }
        return indexToRemove;
    }

    private static void removeIndex(Queue<String> queue, int indexToRemove) {
        int index = 0;
        for (Iterator<String> iterator = queue.iterator(); iterator.hasNext() && index <= indexToRemove; index++) {
            iterator.next();
            if (index == indexToRemove) {
                iterator.remove();
            }
        }
    }
}

import java.util.Iterator；
导入java.util.LinkedList；
导入java.util.Queue；
公共类队列示例{
公共静态void main（字符串[]args）{
Queue Queue=new LinkedList（）；
队列。添加（“a”）；
添加（“b”）；
添加（“c”）；
队列。添加（“a”）；
添加（“d”）；
队列。添加（“a”）；
添加（“b”）；
System.out.println（“在：+队列之前”）；
移除（队列“a”）；
System.out.println（“之后：“+队列”）；
}
公共静态无效删除（队列、字符串删除）{
int indexToRemove=findLastIndex（队列，toRemove）；
removeIndex（队列、索引或移动）；
}
私有静态int findLastIndex（队列，字符串值）{
int indexToRemove=-1；
int指数=0；
for（Iterator Iterator=queue.Iterator（）；Iterator.hasNext（）；index++）{
字符串current=iterator.next（）；
如果（值等于（当前））{
indexToRemove=索引；
}
}
返回索引移动；
}
私有静态void removeIndex（队列队列，int indexToRemove）{
int指数=0；
对于（Iterator Iterator=queue.Iterator（）；Iterator.hasNext（）&&index来说，与d.j.brown的观点非常一致，堆栈最适合您的情况。事实上，有一个内置函数返回堆栈元素的lastIndexo。下面是工作示例

public static void main(String[] args) {
    Stack<String> stack = new Stack<>();
    stack.add("a");
    stack.add("e");
    stack.add("b");
    stack.add("k");
    stack.add("b");
    stack.add("c");
    stack.add("l");

    System.out.println("Original stack: " + stack);
    remove(stack, "a");
    System.out.println("Modified stack: " + stack);
  }

  private static void remove(Stack<String> stack, String toRemove) {
    int indexOfToRemove = stack.lastIndexOf(toRemove);
    if (indexOfToRemove == -1) {
      return;
    }
    Stack<String> tempStack = new Stack<>();
    int originalSize = stack.size();
    for (int i = 0; i < originalSize - indexOfToRemove - 1; i++) {
      tempStack.push(stack.pop());
    }
    stack.pop();  //Extra pop to remove the desired element
    System.out.println("Temporary stack: " + tempStack);
    while (!tempStack.empty()) {
      stack.push(tempStack.pop());
    }
  }

使用Deque。您可以在两侧添加/删除。
deque.getLast（），deque.getFirst（）会给你你想要的。
最后一次出现对你来说意味着什么？索引？@JacobG。还有什么可以表示基于列表的结构中的最后一个元素？@AKSW只有
Queue
s不是
list
s。它们唯一的共同点是它们都是
Collection
s.@DSlomer64，如果你想评论一篇帖子，请使用评论，而不是修改问题来添加评论。@BhargavRao——我记得，我找不到合适的地方来粘贴我的评论，所以，我记得，我写了一个类似“编辑”的注释然后把我修改过的编辑放在那里。我记得，我花了很多精力。你能把我写的东西发给我吗？我是个新手，有时不清楚我是在审查当前尚未批准的编辑还是原始问题，或者我的话放在哪里。有什么地方可以让我对这一切有更好的感觉吗？
Original stack: [a, e, b, k, b, c, l]
Temporary stack: [l, c, b, k, b, e]
Modified stack: [e, b, k, b, c, l]