Java 如何在实现的队列中使用迭代器

我有一个任务来编码下面的类。。。迭代器（）方法中有一个问题 我有很多错误，我不知道如何改正它。。你能建议一种在iterator（）方法下更正代码的方法吗。。。您还可以看到类的其他部分……我将eclipse的注释放在每一行的旁边。。谢谢

package queue;
import java.util.*;

public class FifoQueue<E> extends AbstractQueue<E> implements Queue<E> {
    private QueueNode<E> last;
    private int size;

    public FifoQueue() {

    }

    /** 
     * Returns an iterator over the elements in this queue
     * @return an iterator over the elements in this queue
     */ 
    public Iterator<E> iterator() {
        QueueNode<E> position =last;
        Iterator itr = position.iterator(); // The method iterator() is //undefined for the type FifoQueue.QueueNode<E>- Iterator is a raw type. References //to generic type Iterator<E> should be 
     parameterized
        while(itr.hasNext){ // hasNext cannot be resolved or is not a field
            int object=itr.next(); //Type mismatch: cannot convert from Object to int
        return object; //Type mismatch: cannot convert from int to Iterator<E>

            }
        }

    /** 
     * Returns the number of elements in this queue
     * @return the number of elements in this queue
     */
    public int size() {     
        return size;
    }

    /** 
     * Inserts the specified element into this queue, if possible
     * post:    The specified element is added to the rear of this queue
     * @param   x the element to insert
     * @return  true if it was possible to add the element 
     *          to this queue, else false
     */
    public boolean offer(E x) {
        QueueNode<E> q = new QueueNode<E>(x);
        if(last!=null){
        q.next=last.next;
        last.next=q;
        return true;

        } else {
        return true;
    }
    }

    /** 
     * Retrieves and removes the head of this queue, 
     * or null if this queue is empty.
     * post:    the head of the queue is removed if it was not empty
     * @return  the head of this queue, or null if the queue is empty 
     */
    public E poll() {
        if( last==null){
            return null;
        }
            QueueNode<E> n=last.next;   
            last.next=last.next.next;
            size=size-1;
            return n.element;

        }


    /** 
     * Retrieves, but does not remove, the head of this queue, 
     * returning null if this queue is empty
     * @return  the head element of this queue, or null 
     *          if this queue is empty
     */
    public E peek() {
        if(last==null){
            return null;
        }
        QueueNode<E> n=last;
        while(n.next !=null){

        }
        return n.element;
    }


    private static class QueueNode<E> {
        E element;
        QueueNode<E> next;

        private QueueNode(E x) {
            element = x;
            next = null;
        }

    }

}

包队列；
导入java.util.*；
公共类FifoQueue扩展AbstractQueue实现队列{
最后是私有排队节点；
私有整数大小；
公共FifoQueue（）{
}
/** 
*返回此队列中元素的迭代器
*@返回此队列中元素的迭代器
*/ 
公共迭代器迭代器（）{
队列节点位置=最后一个；
迭代器itr=position.Iterator（）；//对于类型FifoQueue.QueueNode，方法迭代器（）是//未定义的-迭代器是原始类型。对泛型类型迭代器的引用//应该是
参数化
而（itr.hasNext）{//hasNext无法解析或不是字段
int object=itr.next（）；//类型不匹配：无法从对象转换为int
返回对象；//类型不匹配：无法从int转换为迭代器
}
}
/** 
*返回此队列中的元素数
*@返回此队列中的元素数
*/
公共整数大小（）{
返回大小；
}
/** 
*如果可能，将指定的元素插入此队列
*post：指定的元素被添加到此队列的后面
*@param x要插入的元素
*@如果可以添加元素，则返回true
*到该队列，否则为false
*/
公共布尔报价（E x）{
QueueNode q=新的QueueNode（x）；
if（last！=null）{
q、 next=last.next；
last.next=q；
返回true；
}否则{
返回true；
}
}
/** 
*检索并删除此队列的头，
*如果此队列为空，则为null。
*post：如果队列的头不是空的，则它将被删除
*@返回此队列的头，如果队列为空，则返回null
*/
公众电子投票{
if（last==null）{
返回null；
}
QueueNode n=last.next；
last.next=last.next.next；
尺寸=尺寸-1；
返回n元素；
}
/** 
*检索但不删除此队列的头，
*如果此队列为空，则返回null
*@返回此队列的head元素，或null
*如果此队列为空
*/
公共E peek（）{
if（last==null）{
返回null；
}
QueueNode n=最后一个；
while（n.next！=null）{
}
返回n元素；
}
私有静态类队列节点{
E元素；
排队节点下一步；
专用队列节点（E x）{
元素=x；
next=null；
}
}
}

您的

迭代器（）

方法需要返回

迭代器接口的实现。您可能希望以私有内部类的形式执行此操作，因此它可以访问队列字段

迭代器类需要保持当前位置，并在调用
next（）
时遍历节点

您可能希望实现快速失效逻辑，以防止在迭代时更新队列时出现问题。向队列添加更改计数器，并在更改时递增（插入/删除）。记住创建迭代器时的更改计数器，如果调用
next（）
，则抛出
ConcurrentModificationException

这是一个让您开始的框架：

public Iterator<E> iterator() {
    return new FifoIterator();
}

private final class FifoIterator implements Iterator<E> {
    private QueueNode<E> curr;
    FifoIterator() {
        this.curr = FifoQueue.this.last;
    }
    @Override
    public boolean hasNext() {
        return (this.curr != null);
    }
    @Override
    public E next() {
        if (this.curr == null)
            throw new NoSuchElementException();
        this.curr = this.curr.next;
        E e = this.curr.element;
        if (this.curr == FifoQueue.this.last)
            this.curr = null;
        return e;
    }
}

公共迭代器迭代器（）{
返回新的FifoIterator（）；
}
私有final类FifoIterator实现迭代器{
专用排队节点curr；
第五迭代器（）{
this.curr=FifoQueue.this.last；
}
@凌驾
公共布尔hasNext（）{
返回（this.curr！=null）；
}
@凌驾
公共教育{
if（this.curr==null）
抛出新的NoTouchElementException（）；
this.curr=this.curr.next；
E=该电流元素；
if（this.curr==FifoQueue.this.last）
this.curr=null；
返回e；
}
}
您不能对任何内容调用
.iterator（）
；您的
QueueNode
似乎没有
iterator（）
实现。您需要编写一个实现
Iterator
的类，并填写
hasNext（）
、
next（）
和
remove（）
方法。Vaseph 2
QueueNode
它应该是一个元素的队列Louis Wasserman，所以您的意思是
Iterator itr=position.Iterator（）
不是必需的，但是`while（itr.hasNext）{`是必需的？？？@Override的含义是什么？为什么在代码中使用多个子类？如果（this.curr==FifoQueue.this.last）

为什么要编写

FifoQueue

感谢javadoc。--不知道“多个子类”是什么意思吗。有一个内部类实现一个接口。没有子类。--给定

poll（）

实现，您的节点处于

next

引用的循环链中，因此如果您通过转到

next

继续推进迭代器，您将在何时停止？回答：当您回到开始的位置时。