循环双链表ListIterator

Question

This is a homework question. I have a Double Linked Node class, Circular Double Linked List class which implements Iterable , and a Iterator class that implements Iterator. I understand the concept of an iterator where an implicit cursor sits between two nodes and on a call to next() it returns the node it just jumped over. I created a test class with a new list object. I then created an iterator and called next, I received the correct No Such Element exception but when I added some nodes to the list I received a Null Pointer Exception instead of it returning the last returned node. How can I correct this?

My Node class:

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

}

The List class with the private inner Iterator class:

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

I don't see where you assign values to private DoubleLinkedNode<E> nextItem; when you create iterator. I cannot see the whole code. So I assume that nextItem is null or its next field is null.