これは日食の問題に関連している可能性がありますが、おそらく私のコードのどこかに問題があります。とにかく、私は 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);
}
}
}