1

我正在做一个学习练习并使用迭代器创建我自己的链表。课程如下：

public class LinkedList<T> implements Iterable <T> {
    private Node<T> head;
    private Node<T> tail;
    private int size;

    public LinkedList() {
        head = new Node<T>();
        tail = new Node<T>();
        head.setNext(tail);  
        tail.setPrevious(head);
        size = 0;
    }

    public void append(T element) {
        tail.getPrevious().setNext(new Node<T>(element));
        tail.getPrevious().getNext().setNext(tail);
        tail.getPrevious().getNext().setPrevious(tail.getPrevious());
        tail.setPrevious(tail.getPrevious().getNext()); 
        size++;
    }

    public void prepend(T element) {
        head.getNext().setPrevious(new Node<T>(element));
        head.getNext().getPrevious().setPrevious(head);
        head.getNext().getPrevious().setNext(head.getNext());
        head.setNext(head.getNext().getPrevious());
        size++;
    }

    public void remove(Node<T> nodeToRemove) {
        if(!isEmpty()) {
            nodeToRemove.getPrevious().setNext(nodeToRemove.getNext());
            nodeToRemove.getNext().setPrevious(nodeToRemove.getPrevious());
            nodeToRemove.setNext(null);
            nodeToRemove.setPrevious(null);
            nodeToRemove.setElement(null);
            nodeToRemove = null;
            size--;
        }
    }


    public boolean isEmpty() {
        return size() == 0;
    }

    public int size() {
        return size;
    }   

    public Iterator<T> iterator() {
        return new Cursor<T>(head);
    }

    public String toString() {
        String result = "";

        for(T t : this) {
            result += t.toString() + "\n";
        }

        return result;
    }

    private final class Cursor<E> implements Iterator<E> {
        private Node<E> current;

        public <E> Cursor(Node<E> head) {
            this.current = current;
        }

        public boolean hasNext() {
            return current.getNext().getNext() != null;
        }

        public E next() {
            current = current.getNext();

            return current.getElement();
        }

        public void remove() {
            remove(current);
        }
    }
}

在做了相当多的研究之后，实现迭代器的一个好方法似乎是将它作为一个内部类来实现。但是，我在游标类中的 remove 方法出现编译错误。我相信这是因为类型不匹配，尽管我得到的错误remove()不能LinkedList<T>.Cursor<E>应用于<Node<E>）。

我已经为此苦苦挣扎了很长一段时间，但我不明白到底出了什么问题，我将不胜感激您的任何见解。

4

1 回答 1

2

有几点不对：

  1. 您有 2 个方法称为remove. Java 认为您正在尝试调用不带参数remove的内部Cursor类。您必须像这样限定参考：

    LinkedList.this.remove(current);

  2. 您的内部游标类是非静态的。非静态内部类与创建它们的外部类实例相关联。基本上，它们维护一个指向外部类对象的父指针。这对于实现迭代器是正确的，但是您需要更改使用泛型的方式。非静态内部类可以使用其父类的类型参数。这意味着您可以将迭代器定义更改为：

    private final class Cursor implements Iterator<T>

    它会自动使用<T>from LinkedList。

  3. this.current = current;应该是this.current = head;

  4. 为什么要hasNext调用getNext()两次？

希望有帮助。

于 2012-03-22T02:16:35.220 回答