【发布时间】：2016-08-18 09:02:03
【问题描述】：
通过家庭作业了解 Java 迭代器和通用数据结构。
我已经构建了一个双向链表 (LinkedList)，它使用节点 (LinkedList$Node) 并有一个迭代器 (LinkedList$LinkedListIterator) 所有类都使用泛型。
在 LinkedListIterator 的 @Overridden remove() 方法中，我使用了外部类的方法，即 LinkedList 类。
我收到以下编译时错误：
./LinkedList.java:170: deleteNode(LinkedList<T>.Node<T>,LinkedList<T>.Node<T>,LinkedList<T>.Node<T>) in LinkedList<T> cannot be applied to (LinkedList<T>.Node<T>,LinkedList<T>.Node<T>,LinkedList<T>.Node<T>)
deleteNode(nodeToBeRemoved, next, prev);
我的（原始）理解是类型不匹配，但我看不出这是怎么回事。
这是我的完整课程代码：
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.ConcurrentModificationException;
public class LinkedList<T> implements Iterable<T> {
private Node<T> sentinel;
private long modCount; //apparently no unsigned int's in Java.
public LinkedList() {
modCount = 0;
sentinel = new Node<T>(null);
sentinel.setNext(sentinel);
sentinel.setPrev(sentinel);
}
public void append(T t) {
/*
APPEND:
...
[-----]
| |
[-1st-]
| |
inFront-> [SENTL]
| | <-- [newNode]
behind--> [-----]
| |
[-----]
...
*/
Node<T> newNode = new Node<T>(t);
Node<T> inFront = sentinel;
Node<T> behind = sentinel.prev();
//now actually insert:
insertNode(newNode, inFront, behind);
}
public void prepend(T t) {
/*
PREPEND:
...
[-----]
| |
inFront-> [-1st-]
| | <-- [newNode]
behind--> [SENTL]
| |
[-----]
| |
[-----]
*/
Node<T> newNode = new Node<T>(t);
Node<T> behind = sentinel;
Node<T> inFront = sentinel.next();
//now actually insert:
insertNode(newNode, inFront, behind);
}
public void removeHead() {
/*
REMOVE-FIRST:
...
inFront --> [-----]
| |
[-1st-] <-- *delete*
| |
behind ---> [SENTL]
| |
[-----]
| |
[-----]
...
*/
Node<T> inFront = sentinel.next().next();
Node<T> behind = sentinel;
Node<T> toDelete = sentinel.next();
// now actually delete
deleteNode(toDelete, inFront, behind);
}
private void insertNode(Node<T> newNode, Node<T> inFront, Node<T> behind) {
newNode.setNext(inFront);
newNode.setPrev(behind);
inFront.setPrev(newNode);
behind.setNext(newNode);
modCount++;
}
private void deleteNode(Node<T> toDelete, Node<T> inFront, Node<T> behind) {
inFront.setPrev(behind);
behind.setNext(inFront);
toDelete.setNext(null);
toDelete.setPrev(null);
modCount++;
}
@Override
public Iterator<T> iterator() {
return new LinkedListIterator<T>(sentinel);
}
/*
..:: MyIterator ::..
private inner class
*/
public class LinkedListIterator<T> implements Iterator<T> {
private Node<T> cursor;
private Node<T> lastReturned;
private long iterModCountPerspective;
public LinkedListIterator(Node<T> sentinel) {
cursor = sentinel.next();
lastReturned = null;
iterModCountPerspective = modCount;
}
private boolean hasBodhi() {
// bodhi: in Buddhism, bodhi is the understanding of the "true nature of things".
return (iterModCountPerspective == modCount);
}
@Override
public boolean hasNext() {
if (cursor == sentinel)
return false;
return true;
}
@Override
public T next() {
if (!this.hasNext()) {
throw new NoSuchElementException();
} else if (!hasBodhi()) {
throw new ConcurrentModificationException();
} else {
T aux = cursor.data();
lastReturned = cursor;
cursor = cursor.next();
return aux;
}
}
@Override
public void remove() {
//check we're allowed to remove:
if (lastReturned == null) {
throw new IllegalStateException();
}
if (!hasBodhi()) {
throw new ConcurrentModificationException();
}
//setup vars to perform deletion:
Node<T> nodeToBeRemoved = lastReturned;
Node<T> next = nodeToBeRemoved.next();
Node<T> prev = nodeToBeRemoved.prev();
// now delete
deleteNode(nodeToBeRemoved, next, prev);
iterModCountPerspective++;
//now setup vars for exit:
cursor = next;
lastReturned = null; // illegal to remove yet-again before first calling next()
}
}
/* ..:: Node ::..
private, compositional inner class
Interface:
void setNext(Node n) // change the Node in front of this Node
void setPrev(Node p) // change the Node behind this Node
Node next() // returns the Node in front of this Node
Node prev() // returns the Node behind this Node
T data() // returns the data stored inside this Node
*/
private class Node<T> {
private T data;
private Node<T> next;
private Node<T> prev;
public Node(T d) {
data = d;
next = null;
prev = null;
}
/*
METHOD setNext(Node<T> n)
This method takes the parameter Node
passed-in and puts it in front of this
Node.
input - Node n
output - none
eg: node4.setNext(node5);
*/
public void setNext(Node<T> n) {
next = n;
}
/*
METHOD setPrev(Node<T> n)
This method takes the parameter Node
passed-in and puts it behind of this
Node.
input - Node p
output - none
eg: node5.setPrev(node4);
*/
public void setPrev(Node<T> p) {
prev = p;
}
/*
METHOD next()
This method returns the Node in
front of this Node.
input - none
output - Node infront of this (this.next)
eg: Node nodeInFrontOfNode4 = node4.next();
*/
public Node<T> next() {
return next;
}
/*
METHOD prev()
This method returns the Node
behind of this Node.
input - none
output - Node behind of this (this.prev)
eg: Node nodeBehindOfNode4 = node4.prev();
*/
public Node<T> prev() {
return prev;
}
/*
METHOD data()
This method returns the data
inside of this Node.
input - none
output - Data inside of this Node
eg: PlanarShape shape4 = node4.data();
*/
public T data() {
return data;
}
}
}
Comp-sci 学生，第一次海报。 感谢所有 SO 大师。你帮助了我和我的同龄人很多次
【问题讨论】：
-
欢迎来到 StackOverflow！您的问题的描述非常清楚，但是您也发布了大量的代码。下次，尝试将代码缩小到会导致相同问题的最小示例。
-
通常这意味着您有两个实际上不同但名称相同的东西。在这种情况下，我一眼就能看出它不应该是
private class Node<T>，而是private class Node。 -
同样，
public class LinkedListIterator<T> implements Iterator<T>应该是public class LinkedListIterator implements Iterator<T>。目前，您正在LinkedListIterator和Node类上定义一个新的泛型类型。请注意，即使使用了T，所有三个T's（包括LinkedList<T>中的一个）都是不同的。 -
@RohitJain，你的评论应该是一个答案......实际上这就是他看到错误的原因......
-
@AndrewWilliamson 已确认。谢谢。
标签： java compiler-errors iterator inner-classes iterable