Java 从头开始实现ADT链表

我有一个类项目，我必须从头开始构建一个基于ADT的链表（这意味着我不能使用任何标准的Java ADT），然后用它按字母顺序对一堆

状态

对象进行排序（每个对象还包含一个

城市

的链表）。很明显，代码的主干是手工制作的

OrderedLinkedList

类，我很难弄清楚如何实现一个

findOrAdd

方法，该方法迭代列表，如果传递的参数不在列表中，则将其添加到适当的位置（如果元素已经存在，则返回该元素）。我读到的关于实现链表的大部分内容都不涉及ADT，因此很难在我的脑海中转换它，并且仍然对它感到困惑。我的（公认不完整的）OLL代码及其附带的迭代器：

import java.util.Iterator;

public class OrderedLinkedList<E extends Comparable<E>> implements Iterable<E> 
{
    private E first;
    private E next;
    private E last;
    private E current;
    private E temp;
    private int size;

    public OrderedLinkedList() 
    {
        this.first = null;
        this.next = null;
        this.last = null;
        this.current = null;
        this.size = 0;
    }

    public E findOrAdd(E element)
    {
        E returnVal = null;
        Iterator<E> listIter = this.iterator();

        if (this.first == null)
        {
            this.first = element;
            this.size++;
        }

        else 
            for (int i = 0; i < this.size; i++)
                {
                    if (listIter.next().compareTo(element) == 1 && listIter.hasNext() == false)
                    {
                        temp = this.first;
                        this.first = element;
                        this.next = temp;
                        this.size++;
                    }   
                    else if (listIter.next().compareTo(element) == 1 && listIter.hasNext() == true)
                        continue;
                    else if (listIter.next().compareTo(element) == 0)
                        returnVal = element;
                    else if (listIter.next().compareTo(element) == -1)
                    {
                        temp = this.next;
                        this.next = element;                        
                    }               
                }

        return returnVal;
    }

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

    private class OrdListIterator<E> implements Iterator<E> 
    {
        private E nextNode;

        public OrdListIterator()
        {
            //maybe something needed here
        }

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

        public E next()
        {       
            return (E) next;
        }

        public E first()
        {
            return (E) first;
        }

        public void remove()
        {
            //implement later
        }
    }
}

import java.util.Iterator；
公共类OrderedLinkedList实现Iterable
{
私人电子优先；
下一步是私人股本；
私人住宅；
私有电子流；
私人电子温度；
私有整数大小；
public OrderedLinkedList（）
{
this.first=null；
this.next=null；
this.last=null；
this.current=null；
此值为0.size=0；
}
公共E findOrAdd（E元素）
{
E returnVal=null；
迭代器列表iter=this.Iterator（）；
if（this.first==null）
{
第一个=元素；
这个.size++；
}
其他的
for（int i=0；i

---

我有比较

State

和

City

类中的方法覆盖了通常的方法，但仍然以相同的方式运行。我在

findorad

中哪里出错了？我怎么会出错？我不想对代码或任何东西进行完全更正；我大约99%确信

else

块下的一切都是糟糕的。我只是需要朝着正确的方向努力：找个地方站稳脚跟。我非常感谢您的建议。

我相信您的问题可能在于您正在呼叫

listIter.next（）

对于每个条件，可能意味着您在每次检查时都在推动迭代器。可能您应该在循环开始时存储它，然后在比较中使用单个对象…

哦，这是一个很好的观点。我还没有完全达到使用提供的测试代码的目的，所以我不确定这是否是一个问题，b但是它肯定不适合我。谢谢。欢迎。这解决了你遇到的问题还是你在寻找更进一步的东西？所以根据你的建议来考虑它（我在循环的顶部添加了一个

E current=listIter.next（）；

声明），我实际上需要切换-1和1

if

s的功能，对吗？因此，如果参数位于当前的

之后，循环将在另一个
列表项之后继续
调用，但是如果参数位于当前的
之前，则它会在那里插入，节点标记也会相应地移动。是的，我相信从我所能确定的情况来看，这是正确的。如果您查找的第一个
if
语句小于当前
时出现的第一个节点，则它将被放入相应的位置。compareTo（元素）
返回一个负数。另外，我发现有帮助的方法不是使用
当前值。compareTo（element）==1
使用
当前值。compareTo（element）>0
仅仅是因为契约[对于可比接口，因为它只要求它进一步为正，所以更容易阅读，
current.compareTo（元素）>0
读取当前>元素