Java 在LinkedList上实现自定义迭代器

我正在尝试在我创建的LinkedList类上创建自定义迭代器。我被要求修改add函数，以便它按从最小到最大的顺序添加对象项。（Term是一个简单的类，形式为Term（整数幂））

我不知道如何在addTerm（）中创建一个循环，以便继续搜索下一个元素，查看它是否大于当前的项幂。有人能帮忙吗

import java.util.Iterator;

public class customImpl implements custom{

    private static class Node {
        Term data;
        Node next;
    }

    private Node head;

    private class TermIterator implements Iterator<Term> {

        private Node current;

        private TermIterator(Node start) {
            current = start;
        }

        @Override
        public boolean hasNext() {
            return current != null;
        }

        @Override
        public Term next() {
            Term result = current.data;
            current = current.next;
            return result;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("Not supported");
        }
    }

    /**
     * Add a term to the expression
     *
     * @param term the term to be added.
     */
    @Override
    public void addTerm(Term term) {

        TermIterator iterator = new TermIterator(head);
        Node newNode = new Node();

        while(iterator.hasNext()) {
            if(term.getPower() > iterator.next().getPower()) {
                newNode.next = head;
            }
            else newNode.data = term;
        }

        newNode.data = term;
        newNode.next = head;
        head = newNode;
    }

    /**
     * Returns an iterator over elements of type {@code T}.
     *
     * @return an Iterator.
     */
    @Override
    public Iterator<Term> iterator() {
        return new TermIterator(head);
    }

}

import java.util.Iterator；
公共类customImpl实现自定义{
私有静态类节点{
术语数据；
节点下一步；
}
专用节点头；
私有类TermIterator实现了迭代器{
专用节点电流；
专用术语迭代器（节点开始）{
电流=启动；
}
@凌驾
公共布尔hasNext（）{
返回电流！=null；
}
@凌驾
下一个公共任期（）{
术语结果=当前数据；
当前=当前。下一步；
返回结果；
}
@凌驾
公共空间删除（）{
抛出新的UnsupportedOperationException（“不受支持”）；
}
}
/**
*在表达式中添加一个术语
*
*@param term要添加的术语。
*/
@凌驾
公共有效期（有效期）{
Term迭代器迭代器=新的Term迭代器（head）；
Node newNode=新节点（）；
while（iterator.hasNext（））{
if（term.getPower（）>iterator.next（）.getPower（））{
newNode.next=头部；
}
else newNode.data=术语；
}
newNode.data=术语；
newNode.next=头部；
头=新节点；
}
/**
*返回{@code T}类型元素的迭代器。
*
*@返回一个迭代器。
*/
@凌驾
公共迭代器迭代器（）{
返回新的术语迭代器（head）；
}
}

您无法轻松使用迭代器，因为它通过值而不是节点：

@Override
public void addTerm(Term term) {

    Node newNode = new Node();
    newNode.term = term;


    Node smaller = null; //smaller holds last element smaller than new term
    Node current = head;
    while(current != null) {
        if(term.getPower() > current.term.getPower()) {
            smaller = current;
            break;
        }
        current = current.next;
    }

    if (smaller == null) {
        newNode.next = head;
        head = newNode;
    } else {
        newNode.next = smaller.next;
        smaller.next = newNode;
    }

}

如果要使用迭代器，则应定义“节点”迭代器（并在addTerm方法中使用），然后重新使用它来定义“术语”iteraotr：

class NodeIterator implements Iterator<Node> {

    Node next;

    NodeIterator() {
        next = head;
    }

    @Override
    public boolean hasNext() {
        return (next != null);
    }

    @Override
    public Node next() {
        if (next == null) throw new NoSuchElementException();
        Node res = next;
        next = next.next;
        return res;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("Not supported yet."); 
    }        
}

class TermIterator implements Iterator<Term> {

    final NodeIterator iter = new NodeIterator();

    @Override
    public boolean hasNext() {
        return iter.hasNext();
    }

    @Override
    public Term next() {
        return iter.next().term;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

}

类节点运算符实现迭代器{
节点下一步；
节点运算符（）{
下一个=头部；
}
@凌驾
公共布尔hasNext（）{
返回（下一步！=null）；
}
@凌驾
公共节点下一步（）{
如果（next==null）抛出新的NoSuchElementException（）；
Node res＝next；
next=next.next；
返回res；
}
@凌驾
公共空间删除（）{
抛出新的UnsupportedOperationException（“尚未支持”）；
}        
}
类TermIterator实现了迭代器{
最终节点算子iter=新节点算子（）；
@凌驾
公共布尔hasNext（）{
返回iter.hasNext（）；
}
@凌驾
下一个公共任期（）{
返回iter.next（）.term；
}
@凌驾
公共空间删除（）{
抛出新的UnsupportedOperationException（“尚未受支持”）；//若要更改生成的方法体，请选择“工具”“模板”。
}
}

addTerm

中已经有一个循环，可以完全满足您的要求。我认为您的问题存在于迭代器实现中。您可能希望添加对代码预期操作的解释。另外：

Iterator.next（）

应该在结束后引发

NoSuchElementException

。您的实现获得一个通用的空指针。