Safely Navigating Chains of "Get" Calls with Optional

In Java programming, it is common to encounter chains of "get" calls, such as the following:

house.getFloor(0).getWall(WEST).getDoor().getDoorknob();

To avoid potential NullPointerExceptions, developers often resort to verbose null checks:

if (house != null &&& house.getFloor(0) &&& house.getFloor(0).getWall(WEST) != null &&& house.getFloor(0).getWall(WEST).getDoor() != null) ...

This approach becomes even more unwieldy with longer chains of calls. Is there a more elegant solution?

Yes, with Java 8's introduction of the Optional type, handling nulls in chains of gets has become significantly easier.

Using Optional for Null Handling

Optional is a wrapper class that represents an optional value. It can either contain a non-null value or be empty.

To use Optional for null handling in chains of gets, we can utilize its chaining capabilities with the map() method.

Consider the following example:

Optional.ofNullable(house)
        .map(house -> house.getFloor(0))
        .map(floorZero -> floorZero.getWall(WEST))
        .map(wallWest -> wallWest.getDoor())
        .map(door -> wallWest.getDoor());

This code creates a chain of Optional objects, each representing the result of the corresponding get call.

Benefits of Using Optional

Using Optional offers several benefits:

• Null Checks Handled Automatically: Optional automatically handles null checks, eliminating the need for explicit null checks in your code.
• Safe Get Calls: If any of the get calls returns null, the corresponding Optional will be empty, preventing NullPointerExceptions.
• Fluent API: The chaining capabilities of Optional provide a concise and readable way to handle nulls in chains of gets.

Conclusion

If you are unable to avoid breaking the Law of Demeter, using Optional is a highly recommended approach for safely navigating chains of "get" calls. It provides an elegant and efficient way to handle nulls, ensuring the robustness and reliability of your code.