这可能与 eclipse 的问题有关，但这可能是我的代码某处的问题。无论如何，我有一个 MyLinkedList 类，并且我使用了一个迭代器。当我编写迭代器时，它不允许我通过使用 MyLinkedList.list.add(x, index) 来使用 add 方法。它告诉我：“MyLinkedList 类型中的方法 add(T, int) 不适用于参数 (T, int)”。建议的修复根本不改变任何代码（比如想要将方法的参数类型从 (T, int) 更改为 (T, int)。remove 方法调用相同类型的参数并且工作正常。我会将代码发布到 MyLinkedList 中的 add 方法和迭代器中的 add 方法。
班上：
public void add(T x, int index)
{
if((index < 0) || (index > size))
throw new IndexOutOfBoundsException();
if(size == 0)
{
this.head = this.tail = new Node(x, null, null);
}
else if(index == 0)
{
this.head = new Node(x, this.head, null);
this.head = this.head.getNext().getPrev();
}
else if(index == size)
{
this.tail = new Node(x, null, this.tail);
}
else
{
Node<T> temp = new Node(null, null, null);
temp.setData(x);
if(index < this.size() / 2)
{
temp = this.head;
for(int i = 0; i < index; i++)
{
temp = temp.getNext();
}
}
else
{
temp = this.tail;
for(int i = this.size(); i > index; i--)
{
temp = temp.getPrev();
}
}
temp.getNext().setPrev(temp);
temp.getPrev().setNext(temp);
temp.setData(x);
}
this.size++;
}
迭代器方法：
public void add(T x)
{
if(modCount != expModCount)
throw new ConcurrentModificationException();
MyLinkedList.this.add(x, index); //the problem is in this line
modCount--;
index++;
}
整个程序（肯定有一些事情不完全正确，但我更关注 add 方法的问题。如果您发现代码有任何其他问题并希望指出我正确的方向，这对我也有帮助）：
public class MyLinkedList<T> extends AbstractList<T>
{
private static class Node<T>
{
private T data;
private Node<T> prev;
private Node<T> next;
/**
* Constructor
* @param nodeData - the data in type T that is stored in the node
* @param nodePrev - the node previous to the node initialized
* @param nodeNext - the node following the initialized node
*/
public Node(T nodeData, Node<T> nodePrev, Node<T> nodeNext)
{
this.data = nodeData;
this.prev = nodePrev;
this.next = nodeNext;
}
/**
* gets the node previous to this one
* @return returns the node previous to this
*/
public Node<T> getPrev()
{
return this.prev;
}
/**
* sets the node previous to this
* @param temp the node used to set the previous node to
*/
public void setPrev(Node<T> temp)
{
this.prev = temp.prev;
}
/**
* gets the node after this node
* @return the node following this node
*/
public Node<T> getNext()
{
return this.next;
}
/**
* sets the node after this node in the list
* @param prev - the node
*/
public void setNext(Node<T> prev)
{
this.next = prev.next;
}
/**
* get the data from this node
* @return the data from this node
*/
public T getData()
{
return this.data;
}
/**
* set the data in this node
* @param data - the data to be put in this node
*/
public void setData(T data)
{
this.data = data;
}
}
private int size;
private int modCount;
public Node<T> head;
public Node<T> tail;
/**
* Constructor for MyLinkedList that sets the head and tail of the list to point to null and the size set to 0
*/
MyLinkedList()
{
this.head = new Node<T>(null, null, null);
this.tail = new Node<T>(null, null, null);
this.size = 0;
}
/**
* gets the data from the node specified by the index
* @param index - the index of the node
* @return the data of the node with index index
*/
@Override
public T get(int index)
{
Node<T> temp = new Node(null, null, null);
if((index < 0) || (index > size))
{
throw new IndexOutOfBoundsException();
}
if(index < this.size() / 2)
{
temp = this.head;
for(int i = 0; i < index; i++)
{
temp = temp.getNext();
}
return temp.getData();
}
else
{
temp = this.tail;
for(int i = this.size(); i > index; i--)
{
temp = temp.getPrev();
}
return temp.getData();
}
}
/**
* adds data to the list at the specified index
* @param x - the data to be stored
* @param index - where in the list the data is stored
*/
public void add(T x, int index)
{
if((index < 0) || (index > size))
throw new IndexOutOfBoundsException();
if(size == 0)
{
this.head = this.tail = new Node(x, null, null);
}
else if(index == 0)
{
this.head = new Node(x, this.head, null);
this.head = this.head.getNext().getPrev();
}
else if(index == size)
{
this.tail = new Node(x, null, this.tail);
}
else
{
Node<T> temp = new Node(null, null, null);
temp.setData(x);
if(index < this.size() / 2)
{
temp = this.head;
for(int i = 0; i < index; i++)
{
temp = temp.getNext();
}
}
else
{
temp = this.tail;
for(int i = this.size(); i > index; i--)
{
temp = temp.getPrev();
}
}
temp.getNext().setPrev(temp);
temp.getPrev().setNext(temp);
temp.setData(x);
}
this.size++;
}
/**
* gets the size of the list
* @return the size of the list
*/
@Override
public int size()
{
return this.size;
}
/**
* @return returns whether or not the list is empty
*/
public boolean isEmpty()
{
return (this.size() == 0);
}
/**
* clears the list by setting the head and tail of the list equal to null and the size equal to 0
*/
public void clear()
{
this.head = new Node<T>(null,null,null);
this.tail = new Node<T>(null,null,null);
this.tail = this.head.getNext();
this.size = 0;
}
/**
* removes a node from the list
* @return the data from the removed node
*/
public T remove(int index)
{
Node<T> temp;
if ((index < 0) || (index >= size) || isEmpty())
{
throw new IndexOutOfBoundsException();
}
if(index == 0)
{
temp = new Node(this.head.getData(), null, this.head.getNext());
this.head = this.head.getNext();
}
else
{
Node<T> prev = new Node(null,null,null);
prev = getNth(index - 1);
temp = new Node(prev.getNext().getData(), null, null);
}
this.size--;
return temp.getData();
}
/**
* gets the node at the index index
* @param index - the index of the node we want to return
* @return the node at the specified index
*/
private Node<T> getNth(int index)
{
Node<T> temp;
if(index < 0 || index > size)
throw new IndexOutOfBoundsException();
if(index < this.size() / 2)
{
temp = this.head;
for(int i = 0; i < index; i++)
{
temp = temp.getNext();
}
}
else
{
temp = this.tail;
for(int i = this.size(); i > index; i--)
{
temp = temp.getPrev();
}
}
return temp;
}
private class Iterator<T> implements ListIterator<T>
{
private Node<T> currentNode;
private int expModCount = modCount;
int index = 0;
/**
* adds the data to the list using the add method from MyLinkedList
*/
@Override
public void add(T x)
{
if(modCount != expModCount)
throw new ConcurrentModificationException();
MyLinkedList.this.add(x, index);
modCount--;
index++;
}
/**
* @return returns true if the current node is not the tail, returns false if the current node is the tail of the list
*/
@Override
public boolean hasNext()
{
if (currentNode.equals(MyLinkedList.this.tail))
return false;
else
return true;
}
/**
* @return returns true if the current node is not the head of the list, returns false if the current node is the head of the list
*/
@Override
public boolean hasPrevious()
{
if (currentNode.equals(MyLinkedList.this.head))
return false;
else
return true;
}
/**
* @return the data from the next node
*/
@Override
public T next()
{
if(modCount != expModCount)
throw new ConcurrentModificationException();
if(hasNext() == false)
throw new NoSuchElementException();
T nextData = currentNode.getData();
currentNode.setData(currentNode.getNext().getData());
index++;
return nextData;
}
/**
* @return the index of the next node
*/
@Override
public int nextIndex()
{
return index + 1;
}
/**
* @return the data from the previous node
*/
@Override
public T previous()
{
if(modCount != expModCount)
{
throw new ConcurrentModificationException();
}
if(hasPrevious() == false)
{
throw new NoSuchElementException();
}
T prevData = currentNode.getPrev().getData();
currentNode.setData(currentNode.getPrev().getData());
index--;
return prevData;
}
/**
* @return the index of the previous node
*/
@Override
public int previousIndex()
{
return index - 1;
}
/**
* removes a node using the MyLinkedList remove method
*/
@Override
public void remove()
{
if(modCount != expModCount)
throw new ConcurrentModificationException();
MyLinkedList.this.remove(currentNode);
modCount--;
}
/**
* sets the data of the current node
* @param x - the data to set to the current node.
*/
@Override
public void set(T x)
{
currentNode.setData(x);
}
}
}