Null Pointer Exception in Java

In this tutorial, we are going to learn the Null pointer exception in Java. Null pointer exception is a runtime exception. Null is a special kind of value that can be assigned to the reference of an object. Whenever one tries to use a reference that has the Null value, the NullPointerException is raised.

Different Scenarios for the Null Pointer Exception

Observe some of the following scenarios where NullPointerException can be raised.

Computing the size or length of the Null as if it were an array of elements.

FileName: ThrowNullExcep.java

public class ThrowNullExcep
{
// main method
public static void main(String args[])
	{
		int arr[] = null; // array is assigned a null value
		System.out.println("The length of the array arr is: " + arr.length);
	}
}

Output:

Exception in thread "main" java.lang.NullPointerException: Cannot read the array length because "" is null at ThrowNullExcep.main(ThrowNullExcep.java:7)

Calling a method using the object that has the Null value.

FileName: ThrowNullExcep1.java

public class ThrowNullExcep1
{
	public void foo()
	{
	    System.out.println("In the method foo.");
	}

	public static void main(String args[])
	{
		ThrowNullExcep1 obj = null; // assigning null value
		
		// invoking the method foo()
		obj.foo();
	}
}

Output:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "ThrowNullExcep1.foo()" because "" is null
	at ThrowNullExcep1.main(ThrowNullExcep1.java:13)

When you try to synchronize over a NULL object.

FileName: ThrowNullExcep2.java

// A Java program that synchronizes over a NULL object.
import java.util.*;
import java.io.*;

// A Class that is required for sending the message
class Sendr
{
public void sendMethod(String mssg)
{
	System.out.println("Sending message: " + mssg );
	try
	{
		Thread.sleep(100);
	}
	catch (Exception exp)
	{
		System.out.println("Thread interrupted." + exp);
	}
	System.out.println("\n" + mssg + " is sent");
}
}

// A Class that is used to send messages with the help of threads Threads
class ThreadSend extends Thread
{
private String mssg;
Sendr sendr;

// Received a messge obj and the string
// mssge that has to be sent
ThreadSend(String mStr, Sendr obj)
{
	mssg = mStr;
	sendr = obj;
}

public void run()
{
	// Only a single thread is allowed to send a message
	// at a time.
	synchronized(sendr)
	{
		// synchronizing the send object
		sendr.sendMethod(mssg);
	}
}
}

// Driver class
public class ThrowNullExcep2
{
// main method
public static void main(String args[])
{
	Sendr sendObj = null;
	ThreadSend Sth1 = new ThreadSend( " Hello " , sendObj );
	ThreadSend Sth2 = new ThreadSend( " Bye Bye " , sendObj );

	// Starting the two threads of the ThreadedSend type
	Sth1.start();
	Sth2.start();

	// waiting for the threads to end
	try
	{
		Sth1.join();
		Sth2.join();
	}
	catch(Exception exp)
	{
		System.out.println("Interrupted : " + exp);
	}
}
}

Output:

Exception in thread "Thread-0" Exception in thread "Thread-1" java.lang.NullPointerException: Cannot enter synchronized block because "this.sendr" is null
	at ThreadSend.run(ThrowNullExcep2.java:42)
java.lang.NullPointerException: Cannot enter synchronized block because "this.sendr" is null
	at ThreadSend.run(ThrowNullExcep2.java:42)

Instead of throwing a value, Null is thrown.

FileName: ThrowNullExcep3.java

// Modifying or accessing the fields of the Null object. 
public class ThrowExcep3
{
	int a;

    // main method
	public static void main(String args[])
	{
	    //  assigning a null value
		ThrowExcep3 obj = null;
		obj.a = 3;
	}
}

Output:

Exception in thread "main" java.lang.NullPointerException: Cannot assign field "a" because "" is null
	at ThrowExcep3.main(ThrowExcep3.java:10)

Requirement of NULL Value

A null is a special value that is used in Java. It is usually used to show that there is no value that is being assigned to the reference variable. A null value is mainly used in the implementation of data structures such as a linked list or tree. It is also used in the Singleton pattern.

Avoiding the NullPointerException

In order to avoid the NullPointerException, one should ensure that the initialization of all of the objects is done properly before one can use them. When one declares a reference variable, one should verify that the null value is not assigned to the reference before the reference value is used to access the field or method.

Observe the following common problems with the solution.

Case 1: Comparison of strings with the literal

One of the common problems includes the comparison of a literal with a String variable. The literal can be an element from an Enum or from a String. Instead of invoking the method from the null object, consider invoking it using the literal.

FileName: NullPntrExcption.java

import java.io.*;
 
public class NullPntrExcption
{
// main method
public static void main (String[] args)
{
    // Initializing a String variable with a null value
    String pntr = null;

    // Checking if pntr.equals null or works fine.
    try
    {
        // The following line of code will raise the NullPointerException
        // It is because the pntr is null
        if (pntr.equals("JTP"))
        {
            System.out.print("String are the same.");
        }
        else
        {
            System.out.print("Strinng are not the same.");
        }
    }
    catch(NullPointerException e)
    {
        System.out.print("NullPointerException has been caught.");
    }
}
}

Output:

NullPointerException has been caught.

Now, let's see how one can avoid it.

FileName: NullPntrExcption1.java

public class NullPntrExcption1
{
// main method
public static void main (String[] args)
{
    // Initializing a String variable with a null value
    String pntr = null;

    // Checking if pntr.equals null or works fine.
    try
    {
        // Now, the following line of code will not raise the NullPointerException
        // It is because the string literal is invoking the equals() method
        if ("JTP".equals(pntr))
        {
            System.out.print("String are the same.");
        }
        else
        {
            System.out.print("Strinng are not the same.");
        }
    }
    catch(NullPointerException e)
    {
        System.out.print("NullPointerException has been caught.");
    }
}
}

Output:

NullPointerException has been caught.

Case 2: Keeping an Eye on the method arguments

One must check the method arguments first for the null values and then go with the method execution. Otherwise, there are fair chances that it will throw an IllegalArgumentException and will also signal the calling method that it is wrong with the arguments that have been passed.

FileName: NullPntrExcption2.java

// A program for demonstrating that one must
// check the parameters are null or not before
// using them.
import java.io.*;

public class NullPntrExcption2
{
public static void main (String[] args)
{
    // String st is an empty string  and invoking method getLength()
    String st = "";
    try
    {
        System.out.println(getLength(st));
    }
    catch(IllegalArgumentException exp)
    {
        System.out.println("IllegalArgumentException has been caught.");
    }

    // String s set to a value and invoking method getLength()
    st = "JTP";
    try
    {
        System.out.println(getLength(st));
    }
    catch(IllegalArgumentException exp)
    {
        System.out.println("IllegalArgumentException has been caught.");
    }

    // Setting st with a value null and invoking method getLength()
    st = null;
    try
    {
        System.out.println(getLength(st));
    }
    catch(IllegalArgumentException exp)
    {
        System.out.println("IllegalArgumentException has been caught. " + exp);
    }
}

// method taht computes the length of a string st. 
// It throws and IllegalArgumentException, if st is null
public static int getLength(String st)
{
    if (st == null)
    {
        throw new IllegalArgumentException("The argument can never be null.");
    }
    return st.length();
}
}

Output:

0
3
IllegalArgumentException has been caught. java.lang.IllegalArgumentException: The argument can never be null.

Case 3: Use of Ternary Operator

One can also use the ternary operator in order to avoid the NullPointerException. In ternary, the Boolean expression gets evaluated first. If the expression is evaluated as true, then the val1 is returned. Else, the val2 is returned.

FileName: NullPntrExcption3.java

// A program for demonstrating the fact that 
// NullPointerException can be avoided using the ternary operator.
import java.io.*;
 
public class NullPntrExcption3
{
    //  main method
    public static void main (String[] args)
    {
        // Initializing String variable with null value
        String st = null;
        String mssge = (st == null) ? "String is Null." : st.substring(0, 5);
        System.out.println(mssge);
 
        // Initializing the String variable with string literal
        st = "javaTpoint";
        mssge = (st == null) ? "" : st.substring(0, 10);
        System.out.println(mssge);
    }
}

Output: