null-safe Java

For those who have used Java, I’m sure that you have encountered a NullPointerException (NPE) atleast once. In this short blog post, I’m going to discuss how to be null-safe whenever you are dealing with these nullable expressions in Java.

Java 8’s Optional

Just recently, I’ve found out about Java 8’s Optional wrapper. It is located in the java.util package.

The idea is simple: wrap Optional in any data type that you think might have a null value.

For example, you have a hash map with a key of String and a value of Integer,

import java.util.*;

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);

And, unintentionally, you try to use the get method of a map on a non-existing key,

Integer dValue = map.get("d");

This might cause unexpected NPEs in your code. And obviously, the solution is to wrap these nullable values in an Optional wrapper.

Optional<Integer> dValueOpt = Optional.ofNullable(map.get("d"));

if (dValueOpt.isPresent()) {
  Integer dValue = dValueOpt.get();
  // do something if it has a value
} else {
  // do something if it doesn't have a value
}

You might have to use Optional.ofNullable most of the time to indicate that the return value of the expression can have null values.

I’m sure you’re wondering:

“Why don’t you just check for null values manually? Wrapping data in Optional will just yield me more keystrokes.”

Integer dValue = map.get("d");

if (dvalue == null) {
  // do something if null
} else {
  // do something if NOT null
}

Of course, Optional has other methods too aside from isPresent() and one of the most important method is flatMap(functionMapper) which chains operations on an Optional value. Personally, I also think it’s better to not use null in your code as much as possible. I don’t know if it is just me but whenever I see null in my Java code, it makes me want to gouge my eye out.

And for those functional programmers out there, I think you’ve noticed that Java is slowly adapting functional programming concepts. I want to discuss more of these concepts but I don’t have much time so that would be for another blog post and it’s going to be a bit FUNctional. ;)

Conclusion

Use java.util.Optional if you think your data might have null values. (Note: Applicable only on Java 8 onwards.)

For more details on the Optional wrapper, you can check the Java 8 API documentation.

Questions? Comments? Or maybe you’ve seen some typo? Put it in the comment section below.