Object value null

Question

I'm new to Java and I'm trying to implement a Linked list (I do know a list class exists for this purpose, but doing it from scratch lets me understand how the language works internally)

In the main method, I declare 4 nodes and initialize 3. Head node for the linked list is set to null. The first time the add function is called with parameters head and newNode, head is null, so I initialize head and assign value of newNode to it. In the main method, I expect that head object should have new values set from add method. But head is still null.

I'd appreciate understanding why this is happening.

Apologies if the code is not clean, Thanks plenty!

public class LinkedList
{
    public void add(Node newNode, Node head)
    {
        if(head == null) 
        {
            head = new Node(); 
            head = newNode;              
        }
        else 
        {
            Node temp = new Node(); 
            temp = head; 

            while(temp.next!=null)
            {
                temp = temp.next; 
            }
            temp.next = newNode; 
        }    
    }

    public void traverse(Node head)
    {
        Node temp = new Node(); 
        temp = head; 

        System.out.println("Linked List:: ");

        while(temp.next!=null);  
        {
           System.out.println(" "  + temp.data); 
            temp = temp.next;
        }
    }

    public static void main(String args[])
    {
        Node head = null;
        Node newNode = new Node(null, 5); 
        Node newNode2 = new Node(null, 15); 
        Node newNode3 = new Node(null,30); 

        LinkedList firstList = new LinkedList(); 

        firstList.add(newNode,head); 

       // Part that I don't understand
       // why is head still null here? 

        if(head==null)
        {
         System.out.println("true");
        }

        firstList.traverse(head); 
        firstList.add(newNode2,head); 
        firstList.traverse(head); 
        firstList.add(newNode3,head); 
        firstList.traverse(head); 

    }

}

public class Node
{
    public Node next; 
    public int data; 

    public Node(Node next, int data)
    {
        this.next = next; 
        this.data = data; 
    }

    public Node()
    {
        this.next = null; 
        this.data = 0; 
    }

}

You might find [this post](http://stackoverflow.com/questions/40480/is-java-pass-by-reference) interesting. When you write `head = new Node()` at the top of your code, you change a local copy of the argument, but that does not change its value in the calling code. — assylias, Aug 30 '12 at 22:22

obataku · Answer 1 · 2012-08-30T22:52:45.833

Java method arguments are pass-by-value.

public void add(Node newNode, Node head)
{
    if(head == null) 
    {
        head = new Node(); 
        head = newNode;              
    }
    ...

The above only modifies the local variable head in the scope of add. A reference to the local variable head in the scope of main is not possible. Perhaps you should return the value if you want the caller to be able to retrieve the new value.

To be completely honest, a major principle of object-oriented programming is to encapsulate; the head of your LinkedList should ideally be a field maintained internally. Why should it be a separate part? If you really wish to have the head isolated, then why aren't traverse and add static? You should try to revise your design. I decided to rewrite your code here.

final class List {

  private Node head;

  public void add(final Node node) {
    if (head == null) {
      head = new Node();
    }
    Node cur;
    for (cur = head; cur.next != null; cur = cur.next)
      ;
    cur.next = node;
  }

  public String toString() {
    final StringBuilder builder = new StringBuilder("Linked List::");
    for (Node cur = head.next; cur != null; cur = cur.next) {
      builder.append("\n ").append(cur.data);
    }
    return builder.toString();
  }
}

final class Node {

  int data;
  Node next;

  Node(final int data) {
    this.data = data;
  }

  Node() { }
}

... then, to test:

  private static Node[] nodesFor(final int... values) {
    int n = values.length;
    final Node[] nodes = new Node[n];
    while (n > 0) {
      nodes[--n] = new Node(values[n]);
    }
    return nodes;
  }

  public static void main(final String[] argv) {
    final List list = new List();
    for (final Node node : nodesFor(5, 15, 30)) {
      list.add(node);
      System.out.println(list);
    }
  }

score 2 · Answer 2 · edited May 23 '17 at 12:12

2

I think that the problem is inside the "add" function. You are only changing the value of "head" inside the function scope, not outside it. You can find useful information about the way that Java treat passing parameters values here.

A good implementation of LinkedList in Java is here.

edited May 23 '17 at 12:12

Community

1
1

answered Aug 30 '12 at 23:07

songokuhd

175
2
1

score 1 · Answer 3 · answered Aug 30 '12 at 22:29

1

Making "head" reference another node has no effect on the calling code (java passes references, which in java are the "values" of the addresses).

You need a permanent reference to the head, so make it a field of your class:

private Node head = new Node(); // the head of your Node tree

public void add(Node newNode, Node parent) {
    // add node to parent.
    // for some calls, the parent will be the head
}

answered Aug 30 '12 at 22:29

Bohemian

412,405
93
575
722

Java passes *values*, not references; the point is that in Java you never actually directly touch the value of an object (like you would be able to in C++), rather you merely hold a reference to it. – obataku Aug 30 '12 at 23:28

perilbrain · Answer 4 · 2012-08-30T22:33:43.287

    firstList.add(newNode,head); 

   /*
    Part you should know is, head is a local variable pointing to null.
    Passing head as parameter doesn't make it feasible to alter this local variable.
    Your check is worthless.
    Make public Node add(Node newNode, Node head) and return head from there.
   */ 
    head=firstList.add(newNode,head);

    if(head==null)
    {
     System.out.println("true");
    }

Eli Turchinsky · Answer 5 · 2012-08-30T23:52:27.287

Here is better implantation of your Linked List. Please Note:

_head should be a private member
Node is an inner mechanism. you should give a data parameter to your add method instead of a Node object

I Wrote this , simple ,yet base on your code, implementation

public class LinkedList{
private Node _head;
public void add(int data)
{               
        //Understand this code! What happens if _head=null?                 
        _head=new Node(_head,data); 
        /*
             //Use the following code for a "Normal" nodes-order
             if(_head==null)
                _head=new Node(null,data);
             else{
               Node temp=_head;
               while( temp.next!=null)
                  temp=temp.next;            
               temp.next=new Node(null,data); 
             }
        */
}
public void traverse()
{
    System.out.println("Linked List:: ");
    Node temp=_head;
    while(temp!=null){
            System.out.println(" "  + temp.data); 
            temp = temp.next;
    }
}
public LinkedList(){
    _head=null;         //null is our lists anchor
}

public static void main(String args[])
{
    LinkedList firstList = new LinkedList(); 

    firstList.add(5); 
    firstList.traverse(); 
    firstList.add(15); 
    firstList.traverse(); 
    firstList.add(30); 
    firstList.traverse(); 

}

}

order this case is a logical concept. It really depends on what you want to do with your code. Ill edit it to show the other option also. — Eli Turchinsky, Aug 30 '12 at 23:38

Object value null

5 Answers5