Efficient Null Checks in Java Using Utility Classes

The article starts with a notice that users can obtain a free programmer book by replying with a keyword in the backend system, and then shifts to a technical discussion about handling null pointer exceptions, which are common bugs in Java code.

When a null pointer occurs, many developers simply add a != null check, but the article proposes a more systematic three‑step approach to perform null checks efficiently.

Step 1: Identify the data type of the variable you need to check. Typical types include String, custom objects, List, arrays, and Map.

Step 2: Choose the appropriate utility class for the identified type. For example: String → StringUtils Object, List, Map, Array → ObjectUtils Array → Arrays Collections → Collections or CollectionUtils Step 3: Use the selected utility class to perform the null or emptiness check.

Examples:

String str = "";</code>
<code>StringUtils.isEmpty(str); // true

The StringUtils.isEmpty method checks both null and empty string cases.

Object obj = null;</code>
<code>ObjectUtils.isEmpty(obj); // true

For Map and List you can also use ObjectUtils or CollectionUtils:

Map<String, Object> map = Collections.emptyMap();</code>
<code>ObjectUtils.isEmpty(map); // true

List<Integer> list = Collections.EMPTY_LIST;</code>
<code>ObjectUtils.isEmpty(list); // true

The source code of ObjectUtils.isEmpty(Object obj) demonstrates how it handles various types:

public static boolean isEmpty(@Nullable Object obj) {</code>
<code>    if (obj == null) { return true; }</code>
<code>    if (obj instanceof Optional) { return !((Optional) obj).isPresent(); }</code>
<code>    if (obj instanceof CharSequence) { return ((CharSequence) obj).length() == 0; }</code>
<code>    if (obj.getClass().isArray()) { return Array.getLength(obj) == 0; }</code>
<code>    if (obj instanceof Collection) { return ((Collection) obj).isEmpty(); }</code>
<code>    if (obj instanceof Map) { return ((Map) obj).isEmpty(); }</code>
<code>    return false;</code>
<code>}

While this method covers many cases, it has limitations: for collections containing a single null element, ObjectUtils.isEmpty returns false. In such scenarios, you need to iterate over the elements and check each one individually.

List<Integer> list = Collections.singletonList(null);</code>
<code>ObjectUtils.isEmpty(list); // false

For arrays of objects, a separate overload exists:

public static boolean isEmpty(@Nullable Object[] array) {</code>
<code>    return array == null || array.length == 0;</code>
<code>}

When you need to verify that every element in a List is empty, you can use:

Arrays.stream(list.toArray()).allMatch(ObjectUtils::isEmpty);

For Map checks, CollectionUtils.isEmpty(map) aggregates both null and isEmpty checks:

public static boolean isEmpty(@Nullable Map<?, ?> map) {</code>
<code>    return map == null || map.isEmpty();</code>
<code>}

Similarly, CollectionUtils.isEmpty(Collection<?> collection) handles null and isEmpty for collections.

In summary, to determine whether a variable is null or empty in Java you should:

Identify its data type.

Select the appropriate utility class (StringUtils for strings, ObjectUtils for most other types, CollectionUtils for collections).

Invoke the corresponding isEmpty method.

For nested collections or arrays, an element‑wise check is required.

Finally, the article reminds readers that they can claim a free programmer book by replying with the keyword “5000” in the backend system.