Sentry Answers>Java>

Avoiding `NullPointerException` in Java

Avoiding `NullPointerException` in Java

Lewis D.

The ProblemJump To Solution

In Java, a NullPointerException occurs when a variable that is being accessed has not yet been assigned to an object, in other words, the variable is assigned as null.

If you have read the Sentry answer to Is Java Pass-By-Reference or Pass-By-Value?, you might know that in Java, variables are simply pointers to objects in memory. Therefore, a null pointer exception will occur when the code is pointing to something in memory that does not exist.

The Java API documentation on NullPointerException lists a couple of scenarios where this exception could be invoked:

  • Calling the instance method of a null object.
  • Accessing or modifying the field of a null object.
  • Taking the length of null as if it were an array.
  • Accessing or modifying the slots of null as if it were an array.
  • Throwing null as if it were a Throwable value.

The Solution

Let’s take a look at a concrete example of where a NullPointerException might be thrown.

Consider the following code example:

Click to Copy
class NullPointerExample { private static void printFirstElement(String[] array) { System.out.println(array[0]); } public static void main(String[] args) { String[] myStringArray = null; printFirstElement(myStringArray); } }

Executing this code will result in the following stack trace:

Click to Copy
Exception in thread "main" java.lang.NullPointerException at NullPointerExample.printFirstElement(NullPointerExample.java:6) at NullPointerExample.main(NullPointerExample.java:11)

This happens because in our printFirstElement() method, we attempted to access the first element of an array which does not exist. Similarly, taking the length of this given array would yield the same result. We could make this code null-safe by adding a check for null before attempting to access the first element:

Click to Copy
class NullPointerExample { private static void printFirstElement(String[] array) { if (null != array){ System.out.println(array[0]); } else{ System.out.println("The array was null!"); } } public static void main(String[] args) { String[] myStringArray = null; printFirstElement(myStringArray); } }

Executing this code now will yield the following output:

Click to Copy
The array was null!

This is one important technique we can use to avoid tumbling into a NullPointerException during code execution. Some tips for avoiding a NullPointerException include:

  • Perform null checks to ensure that objects are correctly initialized before accessing any of the object’s methods.
  • Use primitives (where it makes sense) such as int, boolean and char, as these cannot be assigned as null and therefore cannot cause a NullPointerException.
  • When first initializing objects, attempt to assign default or temporary values to them.
  • Use a tool like FindBugs, which performs static analysis of code and can detect NullPointerException issues before you actually execute any of your code.
  • Use a tool like NullAway which acts on @NotNull and @Nullable annotations.

Further Reading

Is Java Pass-By-Reference or Pass-By-Value?

  • Sentry BlogException Handling in Java (with Real Examples)
  • Syntax.fm logo
    Listen to the Syntax Podcast

    Tasty treats for web developers brought to you by Sentry. Get tips and tricks from Wes Bos and Scott Tolinski.

    SEE EPISODES

Loved by over 4 million developers and more than 90,000 organizations worldwide, Sentry provides code-level observability to many of the world’s best-known companies like Disney, Peloton, Cloudflare, Eventbrite, Slack, Supercell, and Rockstar Games. Each month we process billions of exceptions from the most popular products on the internet.

© 2024 • Sentry is a registered Trademark
of Functional Software, Inc.