What happens to the initial null value set to head of Linked List?

Question

I have been making an implementation of a Linked List to manipulate it to do various things so I could better learn it and I have come across something which I don't understand.

I have made three classes: Node, LinkedListExample, LinkedListTest

My node class looks like:

public class Node {


    Node next;
    Object data;

    // Node constructor
    public Node(Object dataValue) {
        next = null;
        data = dataValue;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object dataValue) {
        data = dataValue;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node nextValue) {
        next = nextValue;
    }

}

My Linked List looks like:

public class LinkedListExample {

    private Node head;
    private int listCount;

    public LinkedListExample() {
        head = new Node(null);
        listCount = 0;
    }

    public void add(Object data) {
        Node temp = new Node(data);
        Node current = head;

        while (current.getNext() != null) {
            current = current.getNext();
        }

        current.setNext(temp);
    }

    public int size() {
        for (Node n = head; n.next != null; n = n.next) {
            listCount++;
        }
        return listCount;
    }

    public String toString() {
        String result = "";
        Node current = head;
        while (current.getNext() != null) {
            current = current.getNext();
            result += current.getData() + " ";
        }
        return result;
    }

    public String headString() {
        String result = "";
        Node current = head;

        //current = current.getNext();
        result = current.getData() + ""; /* Returns null currently */
        /* If previous line replaced by result = current.getData().toString() it would result in NULL POINTER EXCEPTION */
        return result;
    }
}

Finally, my Linked List Test class looks like:

public class LinkedListTest {

    public static void main(String[] args) {

        LinkedListExample example = new LinkedListExample();
        example.add(1);
        example.add(2);
        example.add(3);

        System.out.println("The list looks like: " + example.toString());
        System.out.println("The size is: " + example.size());

        System.out.println("The list head is: " + example.headString());
    }
}

My question is in my constructor, I create a Node object, head, and set it to null. I later go on to add three objects, 1 2 and 3 to my Linked List. I am now confused as to what is in my Linked List? Is the null value included or not? Why or why not?

When I run the program as is, my print statement would say The list looks like 1 2 3. But if I was to flip the lines within the while loop in my toString() method in LinkedListExample to look like:

current = current.getNext();
result += current.getData() + " ";

Then the output would be The list looks like null 1 2.

Does null never get replaced?

The same goes for headString(). It currently outputs The list head is: null but if I were to uncomment the previous line, I would get The list head is: 1.

On a side note, what is also the difference between using "" and toString() because as commented out in the code above, in one situation it prints out null while the other throws a null pointer exception?

Sorry if these questions are simple, I just am lost on this concept.

Answer 1

you create a new Node and set the data value to null. So in your c'tor you create a new Node with next=null and data=dataValue=null.

So your LinkedListExample head is an element:

Node: next=null, data=null

Your add()-method creates a temporary node and sets a (temporary) current node.

Temp: next=null, data=1
Current=head: next=null, data=null

As current has no next you replace it:

Head: next=1, data=null
Next: next=null, data=1

And so on.

You head stays the same, but output null wont have an effect, it's just empty.

So, your null-head never get's replaced and the change in output is because of your

while (current.getNext() != null) {

Answer 2

This is one particular way of implementing a linked list. The "head" node is not counted as part of the list.

If you counted the head node as part of the list, then when you add an item, you will find that you need to add it differently depending on whether it's the first node or not. Removing also works differently depending on whether the node is the first node.

To simplify the code, you can create a "header node" that is not used to store a value. If you do this, then you don't need to think about how to insert or remove nodes at the start of the list. Nodes with data are always after the head node, so they're never at the start.