Zirkular Doppelt LinkedList ListIterator

Dies ist eine Hausaufgaben Frage. Ich habe eine Doppelt Verknüpfte Knoten-Klasse, Kreisförmigen Doppelt verketteten Liste-Klasse, die implementiert Iterable, und einer Iterator-Klasse implementiert Iterator. Ich verstehe das Konzept ein iterator ist, wo eine implizite cursor befindet sich zwischen zwei Knoten und auf einen Anruf zu next() es gibt den Knoten einfach übersprungen. Ich erstellte eine test-Klasse mit einer neuen Liste-Objekt. Dann habe ich einen iterator und next genannt, erhielt ich die richtige No Such Element exception aber wenn ich fügte hinzu, einige Knoten zu der Liste erhielt ich einen Null Pointer Exception statt der Rückkehr der zuletzt zurückgegebene Knoten. Wie kann ich das korrigieren?

Meiner Node-Klasse:

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

}

Die List-Klasse, die mit dem privaten inneren Iterator-Klasse:

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
}