泛型集合实现java编译错误答案

【问题标题】：Generics collection implementation java compilation error泛型集合实现java编译错误
【发布时间】：2012-02-17 22:20:59
【问题描述】：

编辑：

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>

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

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

【问题讨论】：

没用，你也可以试试，代码是可编译的（除了我提到的错误）
除非Node 应该独立于LinkedList，否则不要将节点设为静态内部类。删除 Node 上的泛型参数，因为它隐藏了 LinkedList 中的外部泛型类型 E。
这不是家庭作业，我将其作为我自己项目的一部分，以便使用更友好的用户链表（我不喜欢 Java 的）
好的。我已经删除了作业标签和我之前的评论。

标签： java generics compilation

【解决方案1】：

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

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

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

它强制Node<E> 的静态定义的原因与垃圾收集有关。即使 LinkedList 计划进行垃圾回收，迭代器仍可能持有对 Nodes 的引用。当然，您可以通过特定的实现来防止这种事情发生，但是 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<E> 对象。由于这与您构造 LinkedIterator 类型的范围相同，因此将确保泛型类型安全。

--- 原帖如下----

通过指定您的节点类定义为Node<E>，您基本上创建了第二个独立范围的泛型类型E，它将隐藏LinkedList 类中的外部泛型类型E。

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

应要求，以下是在我的机器上编译的代码，(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;
        }
    }
}

【讨论】：

它可以在我的机器上运行，实际上你发布的代码也可以在我的机器上运行。
问题是如果你创建一个新的迭代器，你不能让它返回 E...这就是我的目标...
好吧，迭代器的问题其实略有不同。我再重写一次。
现在好多了，我再仔细看看，需要几分钟。
LinkedListIterator 应该是对 Iterator 的扩展，并且意味着有更多的选项，比如 moveToNext() 和 moveToPrev() （我的意思是实现一个真正的链表功能），随着你的改变，我必须使用 Iterator，这是我试图避免的，这也是我去实现自己的 LinkedList 而不是使用 java 的原因...

【解决方案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;
        }
    }
}

或者使用 static 类节点。

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;
        }
    }
}

【讨论】：

【解决方案3】：

不明白LinkedListIterator中的和父类是同一个。只需从内部类中删除：

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

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

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

【讨论】：