泛型集合实现java编译错误

Question

编辑：

public class LinkedList<E> {
    private class Node {
        protected Node next, prev;
        protected E data;

        protected Node(E dat) {
            data = dat;
            next = prev = null;
        }
    }

    private Node head, tail;

    public LinkedList() {
        (head = new Node(null)).next = tail = new Node(null);
        tail.prev = head;
        tail.next = head.prev = null;

    }

    public class LinkedListIterator {
        private Node current = null;

        public synchronized void resetToHead() {
            current = head.next;
        }

        public synchronized void resetToTail() {
            current = tail.prev;
        }

        public synchronized E get() {
            if (current!=null) return current.data;
            return null;
        }
    }
}

问题是我在强调的行上收到以下编译错误：

> Type mismatch: cannot convert from LinkedList<E>.Node<E> to
> LinkedList<E>.Node<E>

这是什么意思？我该如何解决这个问题？

顺便说一句，代码只是实现的一部分，所以不要试图从逻辑上弄清楚它。

Answer 1

--- 随着问题略有变化而编辑 ---

现在的问题是，我如何让两个内部类协调泛型类型？简而言之，如果它们都是绑定泛型类型的外部类的内部类，则不必这样做。因此，即使使用非泛型 LinkedListIterator 中的 public synchronized E get() ，您也会返回一个 E （并且它是类型安全的）。

但是，如果您随后尝试实现 java.util.Iterator ，事情就会崩溃，因为 E 基于不同的类（接口），因此 E具有不同的范围。你如何解决这个问题？您需要将 Node 类参数化为 Node 以满足 E 绑定存在于 Iterator 即使该实现在其原始类的范围之外使用。这强制静态定义Node。

它强制 Node 进行静态定义的原因与垃圾收集有关。即使 LinkedList 已计划进行垃圾回收，迭代器仍可能保留对 Node 的引用。当然，您也许能够通过特定的实现来防止这种情况发生，但 JVM 必须允许任何实现（甚至是错误的实现）。

也许用代码来解释会更容易，

  public LinkedList<E> {

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

    // private because we don't want instances created outside of this LinkedList
    private class LinkedIterator implements Iterator<E> {

      // Right here, needing a parameterized next node will force Node to be static
      // static inner classes can exist outside of the scope of their parent
      // Since it can exist outside of the parent's scope, it needs it's own generic parameter
      private Node<E> next;

      LinkedIterator(Node start) {
        next = start;
      }

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

      public E next() {
        Node<E> retValue = next;
        if (retValue != null) {
          next = retValue.next;
        }
        return retValue;
      }

    }

    // must be static because LinkedList might be garbage collected when
    // an Iterator still holds the node.
    // This E is not the same E as in LinkedList, because it is a E declaration (hiding the above E)
    private static Node<E> {
      Node<E> next;
      Node<E> prev;
      E data;
    }

  }

如果你不小心，你现在可能会回到开始的地方；然而，关键是在父作用域中需要时构造新的 Node 对象。由于这与构造 LinkedIterator 类型的范围相同，因此将确保泛型类型安全。

--- 原帖如下 ----

通过指定您的节点类定义是 Node，您基本上创建了第二个独立作用域的泛型类型 E ，它将隐藏 LinkedList 类中的外部泛型类型 E。

由于您的类都不是静态的，因此它们仅存在于 LinkedList 类的上下文中，该类将提供泛型绑定。这意味着您可以将 Node 简化为 Node，但仍将 E 类类型放入 Node 类中。 LinkedListIterator 也是如此，只不过如果您希望它实现 Iterator，您应该指示它实现 Iterator。

由于请求，以下是在我的机器上编译的代码，（java 1.6.0_20）

public class LinkedList<E> {

    private class Node {
        protected Node next, prev;
        protected E data;

        protected Node(E dat) {
            data = dat;
            next = prev = null;
        }
    }

    private Node head, tail;

    public LinkedList() {
        (head = new Node(null)).next = tail = new Node(null);
        tail.prev = head;
        tail.next = head.prev = null;

    }

    public class LinkedListIterator {
        private Node current = null;
        public synchronized void resetToHead() {
            current = head.next;
        }

        public synchronized void resetToTail() {
            current = tail.prev;
        }
    }
}

Answer 2

通过参数化嵌入的类，您做得有点过头了。我删除了所有不必要的。

public class LinkedList<E> {
    private class Node {
        protected Node next, prev;
        protected E data;

        protected Node(E dat) {
            data = dat;
            next = prev = null;
        }
    }

    private Node head, tail;

    public LinkedList() {
        (head = new Node(null)).next = tail = new Node(null);
        tail.prev = head;
        tail.next = head.prev = null;

    }

    public class LinkedListIterator {
        private Node current = null;

        public synchronized void resetToHead() {
        current = head.next;
        }

        public synchronized void resetToTail() {
            current = tail.prev;
        }
    }
}

---

或者使用静态类 Node。

public class LinkedList<E> {
    private static class Node<E2> {
        protected Node next, prev;
        protected E2 data;

        protected Node(E2 dat) {
            data = dat;
            next = prev = null;
        }
    }

    private Node<E> head, tail;

    public LinkedList() {
        (head = new Node(null)).next = tail = new Node(null);
        tail.prev = head;
        tail.next = head.prev = null;

    }

    public class LinkedListIterator {
        private Node<E> current = null;

        public synchronized void resetToHead() {
            current = head.next;
        }

        public synchronized void resetToTail() {
            current = tail.prev;
        }
    }
}

Answer 3

它不明白是在 LinkedListIterator 中是相同的作为父类。只需从内部类中删除：

    public class LinkedListIterator {
        private Node<E> current = null;

        public synchronized void resetToHead() {
            current = head.next;
        }

        public synchronized void resetToTail() {
            current = tail.prev;
        }
    }