Question

I’m having some trouble with NPE’s in a MyLinkedList class that extends AbstractList. I start with these constructors:

The constructor for the private Node class:

public Node(T nodeData, Node<T> nodePrev, Node<T> nodeNext)
    {
        this.data = nodeData;
        this.prev = nodePrev;
        this.next = nodeNext;
    }

The constructor for the MyLinkedList class

MyLinkedList()
{
    this.head = new Node<T>(null, null, null); 
    this.tail = new Node<T>(null, null, null);
    this.size = 0;
}

MyLinkedList(Node<T> head, Node<T> tail, int size)
{
    this.head = head;
    this.tail = tail;
    this.size = size;
}

and here I try to return the node at an index with this method:

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

I think the main problem has something to do with initializing the head and tail as null, but I’m not sure if this is the problem and if it is, how to fix it. Is there a better way to initialize these Nodes to avoid NPE’s?

Answer 1

You’re initializing both the head and the tail of the list with this:

MyLinkedList()
{
    this.head = new Node<T>(null, null, null); 
    this.tail = new Node<T>(null, null, null);
    this.size = 0;
}

This seems to be the main source of your NPE’s, because your iteration doesn’t do any kind of checks. In particular, your method will fail in border conditions (since you already check for lengths before even trying to iterate).

By adding some checks you can avoid those exceptions:

private Node<T> getNth(int index)
{
    Node<T> temp = null; //Always try to initialize your variables if you're going
                         //to return them.
    if(index < 0 || index > size)
        throw new IndexOutOfBoundsException();

    if(index < this.size() / 2)
    {
        temp = this.head;
        for(int i = 0; i < index; i++)
        {
            if(temp.getNext() != null)
                 temp = temp.getNext();
            else
                 break;//Break the iteration if there is not a next node
        }
    }
    else
    {
        temp = this.tail;
        for(int i = this.size(); i > index; i--)
        {
            if(temp.getPrev() != null)
                temp = temp.getPrev();
            else
                break;
        }
    }
    return temp;
}

You can throw some kind of exception instead of breaking the iterations if you want.