When Is a Null Check Really Needed? Avoid Redundant Null Checks in Java

Null checks are frequently added to prevent NullPointerException, but overusing them makes code verbose and hard to maintain.

Distinguish Two Scenarios

1. Null as a valid response – the method contract permits returning null to indicate an empty or missing value.

2. Null as an invalid response – the argument or state is illegal and should be treated as an error.

Scenario 2: Null Is Invalid

When a null argument violates the API contract, abort the execution early by either using an assert with a clear message or throwing an exception such as NullPointerException.

Use assert param != null : "parameter must not be null"; to both stop execution and convey the reason.

Or explicitly throw

throw new NullPointerException("parameter must not be null");

.

Scenario 1: Null Is Valid

When null legitimately represents “no data”, prefer returning an empty collection or a default object instead of null. This lets callers operate without repetitive checks.

If the return type is a collection, return Collections.emptyList() (or an empty set/map) rather than null.

If the return type is not a collection, return a harmless “null object” that implements the expected interface but performs no action.

Example of the Null Object pattern:

public interface Action {
    void doSomething();
}

public interface Parser {
    Action findAction(String userInput);
}

public class MyParser implements Parser {
    private static final Action DO_NOTHING = new Action() {
        public void doSomething() { /* do nothing */ }
    };

    public Action findAction(String userInput) {
        // ... actual lookup logic ...
        if (/* no matching action */) {
            return DO_NOTHING;
        }
        // return real action
    }
}

Calling code can now be simplified:

// Redundant null checks
Parser parser = ParserFactory.getParser();
if (parser == null) { /* handle error */ }
Action action = parser.findAction(input);
if (action == null) { /* do nothing */ } else { action.doSomething(); }

// Streamlined version
ParserFactory.getParser().findAction(input).doSomething();

Additional Tips

Prefer calling "constant".equals(variable) to avoid a possible NullPointerException when the variable may be null.

Java 8 and Guava provide Optional to wrap potentially null values, reducing explicit null checks, though it adds some boilerplate.

If a method truly cannot return a meaningful value, consider throwing an exception instead of returning null.

Source: https://blog.csdn.net/lizeyang/article/details/40040817