Avoiding NullPointerException with Groovy Safe Navigation Operator and Java Optional

When accessing nested object properties in Java, each dereference can cause a NullPointerException, leading developers to write lengthy null‑check chains.

Typical handling involves checking each intermediate object before accessing the next, as shown in the following example: String city = student.getAddress().getCity().getCityCode(); To avoid the exception, developers often write verbose code:

String city = null;
if (student != null) {
    Address address = student.getAddress();
    if (address != null) {
        City city = address.getCity();
        if (city != null) {
            String cityCode = city.getCode();
        }
    }
}

Groovy offers a more concise solution with its safe navigation operator ( ?.), which automatically returns null if any part of the chain is null:

def person = Person.find { it.id == 123 }
def name = person?.name
assert name == null

Using this operator, the previous Java null‑check chain can be reduced to a single line: String cityCode = student?.address?.city?.cityCode; Java 8 provides a similar capability through the java.util.Optional class. Although it lacks a dedicated operator, chaining map calls with Optional.ofNullable yields readable code:

String version = Optional.ofNullable(student)
    .map(Student::getAddress)
    .map(Address::getCity)
    .map(City::getCityCode)
    .orElse("Unknown");

In summary, using Optional with ofNullable and map eliminates repetitive null checks, offering a style comparable to Groovy's safe navigation operator. Future Java versions may introduce a dedicated operator to further simplify null‑safe property access.