Circular Doubly LinkedList ListIterator

Question

Это вопрос домашней работы. У меня есть класс Double Linked Node, класс Circular Double Linked List, который реализует Iterable и класс Iterator, который реализует Iterator. Я понимаю концепцию итератора, где неявный курсор находится между двумя узлами, а при вызове next() он возвращает узел, который он просто перепрыгнул. Я создал тестовый класс с новым объектом списка. Затем я создал итератор и вызвал следующий, я получил правильный No Such Element exception, но когда я добавил некоторые узлы в список, я получил Null Pointer Exception вместо него, возвратив последний возвращенный узел. Как я могу это исправить?

Мой узел Класс:

public class DoubleLinkedNode<E>{ 
private E data; 

private DoubleLinkedNode<E> next; 

private DoubleLinkedNode<E> prev; 


public DoubleLinkedNode(E data, DoubleLinkedNode<E> next, DoubleLinkedNode<E> prev){ 
    this.data = data; 
    this.next = next; 
    this.prev = prev; 
} 
/** 
* Used to construct a node that points to null for its prev and next. 
* @param data Data is a generic variable to be stored in the node. 
*/ 
public DoubleLinkedNode(E data){ 
    this(data, null, null); 
} 


//getters 
public E getData(){ 
    return data; 
} 

public DoubleLinkedNode<E> getNext(){ 
    return next; 
} 

public DoubleLinkedNode<E> getPrev(){ 
    return prev; 
} 
//setters 
public void setData(E data){ 
    this.data = data; 
} 

public void setNext(DoubleLinkedNode<E> next){ 
    this.next = next; 
} 

public void setPrev(DoubleLinkedNode<E> prev){ 
    this.prev = prev; 
} 

@Override public String toString(){ 
    if(data == null){ 
     return null; 
    } 
    else{ 
     return data.toString(); 
    } 
} 

} 

Класс Список с частным внутренним классом итератора:

import java.util.Iterator; 
import java.util.ListIterator; 
import java.util.NoSuchElementException; 


public class CircularDoubleLinkedList<E> implements Iterable<E>{ 

private int size; 
private DoubleLinkedNode<E> head; 


public CircularDoubleLinkedList(){ 
    this.head = null; 
    this.size = 0;  
}  
/** 
* Adds an item to the end of the list. 
* 
* @param data The Data that is to be stored in the node. 
*/ 
public void add(E data){  
    DoubleLinkedNode<E> newNode = new DoubleLinkedNode<E>(data); 
    if(this.head == null){ 
     newNode.setNext(newNode); 
     newNode.setPrev(newNode); 
     this.head = newNode; 
     this.size++; 
     //if list is empty create a new node and insert 
    } 
    else{ 
     DoubleLinkedNode<E> temp = this.head.getPrev(); 
     this.head.getPrev().setNext(newNode); 
     this.head.setPrev(newNode); 
     newNode.setPrev(temp); 
     newNode.setNext(this.head);  
     this.size++; 
    } 
} 
/** 
* Which adds an item at the specified index. 
* 
* @param index The index in which the new Node is added. 
* @param data The data which is to be stored in the node. 
*/ 
public void add(int index, E data){ 
    int currIndex = 0; 
    DoubleLinkedNode<E> currNode = this.head; 
    DoubleLinkedNode<E> nextNode = this.head.getNext(); 
    DoubleLinkedNode<E> prevNode = this.head.getPrev(); 
    DoubleLinkedNode<E> newNode = new DoubleLinkedNode<E>(data); 
    if(index == 0){ 
     prevNode.setNext(newNode); 
     currNode.setPrev(newNode); 
     newNode.setPrev(prevNode); 
     newNode.setNext(currNode); 
     this.head = newNode; 
     this.size++;  
    } 
    else if (index > 0){   
     while(currIndex != this.size){ 
      if(currIndex != index%size){ 
       currIndex++; 
       currNode = currNode.getNext(); 
       nextNode = nextNode.getNext(); 
       prevNode = prevNode.getNext();     
      }else{    
       newNode.setPrev(prevNode); 
       newNode.setNext(currNode); 
       prevNode.setNext(newNode); 
       currNode.setPrev(newNode); 
       currNode = newNode; 
       this.size++; 
       break;          
      } 
     }  
    } 
    else if (index < 0){ 
     while(currIndex != -this.size){ 
      if(currIndex != index%size){ 
       currIndex--; 
       currNode = currNode.getPrev(); 
       prevNode = prevNode.getPrev(); 
       nextNode = nextNode.getPrev(); 
      }else{    
       newNode.setNext(nextNode); 
       newNode.setPrev(currNode); 
       currNode.setNext(newNode); 
       nextNode.setPrev(newNode);   
       currNode = newNode; 
       this.size++; 
       break;          
      } 
     } 
    } 
} 
/** 
* Returns the data stored at the specified index. 
* 
* @param index The index determines the node whose data is returned. 
* @return Returns the data of the node at the index. 
*/ 
public E get(int index){//returns the data stored at the specified index 
    int currIndex = 0; 
    DoubleLinkedNode<E> currNode = this.head; 
    E temp = null;  
    if(index == 0){//zero case   
     temp = currNode.getData(); 
    } 
    else if(index > 0){//positive   
     while(currIndex != this.size){ 
      if(currIndex != index%size){ 
       currIndex++; 
       currNode = currNode.getNext();        
      }else{        
       temp = currNode.getData(); 
       break;          
      } 
     } 
    } 
    else if(index < 0){//negative  
     while(currIndex != -this.size){ 
      if(currIndex != index%size){ 
       currIndex--; 
       currNode = currNode.getPrev(); 
      }else{    
       temp = currNode.getData(); 
       break;          
      } 
     }   
    } 
    return temp; 
} 
/** 
* Which removes and returns an item from the list. 
* 
* @param index Removes the node at the current index. 
* @return Returns the data of the removed node. 
*/ 
public E remove(int index){//which removes and returns an item from the list 
    int currIndex = 0; 
    DoubleLinkedNode<E> currNode = this.head; 
    DoubleLinkedNode<E> nextNode = this.head.getNext(); 
    DoubleLinkedNode<E> prevNode = this.head.getPrev(); 
    E temp = null; 
    if(index == 0){ 
     temp = currNode.getData(); 
     prevNode.setNext(currNode.getNext()); 
     nextNode.setPrev(currNode.getPrev()); 
     this.head = nextNode; 
     size--; 
    } 
    else if(index > 0){//positive   
     while(currIndex != this.size){ 
      if(currIndex != index%size){ 
       currIndex++; 
       currNode = currNode.getNext(); 
       nextNode = nextNode.getNext(); 
       prevNode = prevNode.getNext();     
      }else{        
       temp = currNode.getData(); 
       prevNode.setNext(currNode.getNext()); 
       nextNode.setPrev(currNode.getPrev()); 
       currNode = nextNode; 
       size--; 
       break;          
      } 
     } 
    } 
    else if(index < 0){//negative  
     while(currIndex != -this.size){ 
      if(currIndex != index%size){ 
       currIndex--; 
       currNode = currNode.getPrev(); 
       prevNode = prevNode.getPrev(); 
       nextNode = nextNode.getPrev(); 
      }else{    
       temp = currNode.getData(); 
       prevNode.setNext(currNode.getNext()); 
       nextNode.setPrev(currNode.getPrev()); 
       currNode = prevNode; 
       size--; 
       break;          
      } 
     }   
    } 
    return temp; 
} 
/** 
* Returns the size. 
* 
* @return 
*/ 
public int size(){ 
    return size; 
} 
@Override public String toString(){ 
    String str = "["; 
    int index = 0; 
    DoubleLinkedNode<E> curr = head; 
    if(size == 0){ 
     return "There is no one here to kill.";   
    }else{  
     while (index <this.size) { 
      str += curr.getData(); 
      curr = curr.getNext(); 
      index++; 
       if (index<this.size) { 
        str += ", "; 
       } 
     } 
      str += "]"; 
    } 
    return str; 
    } 
@Override 
public Iterator<E> iterator() { 

    return new CircularDoubleIterator(); 
} 
// Iterator inner class begins 
private class CircularDoubleIterator implements ListIterator<E> { 

    private DoubleLinkedNode<E> nextItem;//reference to next item 
    private int index = 0; 
    private DoubleLinkedNode<E> lastReturned;// the last node to be returned by prev() or next() 
              // reset to null after a remove() or add() 

    @Override 
    public E next() { 
     if(!hasNext()){ 
      throw new NoSuchElementException("No such element."); 
     } 
     else{ 
          nextItem = head; //edited 11Sept13 
      lastReturned = nextItem.getNext(); 
      nextItem = nextItem.getNext(); 
          head = nextItem; //edited 11Sept13 
      index++; 
      return lastReturned.getData(); 


     } 
    } 

    @Override 
    public E previous() { 
     if(!hasPrevious()){ 
      throw new NoSuchElementException("No such element."); 
     } 
     else{  

     index--; 

     return ; 
     } 
    } 

    @Override 
    public int nextIndex() { 
     return index; 
    } 

    @Override 
    public int previousIndex() { 
     return index-1; 
    } 
    @Override 
    public boolean hasNext() { 
     return size != 0; 
    } 

    @Override 
    public boolean hasPrevious() {  
     return size!= 0; 
    } 
    @Override 
    public void remove() { 
    } 

    @Override 
    public void set(E theData) { 
     if(lastReturned == null){ 
      throw new IllegalStateException(); 
     } 
     else{ 
     } 

    } 

    @Override 
    public void add(E theData) { 
     if(size == 0){    
     } 
     else if(size != 0){ 
     } 

    } 

} 

//Iterator inner class ends 
} 

Answer 1

Я не вижу, где вы присвоить значения private DoubleLinkedNode<E> nextItem; при создании итератора. Я не вижу весь код. Поэтому я предполагаю, что nextItem имеет значение null или его поле next равно null.