Checking if an Array Is Null or Empty in Java

1. Overview

In Java, manipulating arrays is a common task, which often involves checking if an array is null or empty. This is crucial for preventing NullPointerExceptions and ensuring our code behaves correctly when dealing with array data structures.

In this tutorial, we’ll explore how to perform these checks effectively.

2. Preparing Examples

Let’s first prepare some example arrays to quickly demonstrate how to check whether an array is empty or null:

final static String[] STR_ARRAY = new String[] { "a", "b", "c", "d" };
final static BigDecimal[] EMPTY_ARRAY = new BigDecimal[] {};
final static String[] NULL_ARRAY = null;

As the code above shows, we have created three arrays: a regular String array with four elements, an empty BigDecimal array, and a String array referencing null.

Next, we’ll address different ways to examine if these three arrays are null or empty.

3. Creating a Check Method

In Java, we can check if an array is null or empty by performing two simple checks:

• null check – using == null
• Empty check – checking the length property of the array to see if it has zero elements

Of course, we want our method to work for all array types. The first idea is to create a generic check method:

static <T> boolean isArrayNullOrEmpty(T[] theArray) {
    return theArray == null || theArray.length == 0;
}

We perform both the null and empty checks. Now, if we pass our example arrays to the method, it achieves the expected results:

assertTrue(isArrayNullOrEmpty(NULL_ARRAY));
assertTrue(isArrayNullOrEmpty(EMPTY_ARRAY));
assertFalse(isArrayNullOrEmpty(STR_ARRAY));

However, we still haven’t discussed one case: primitive type arrays, such as int[], double[], and so on.

So next, let’s take a closer look at primitive type arrays.

4. Handling Primitive Type Arrays

Let’s first create an int[] array as an example:

final static int[] INT_ARRAY = new int[] { 1, 2, 3, 4 };

This array isn’t null or empty. Now, let’s test our generic method using this array and see if we can get the correct result:

assertFalse(isArrayNullOrEmpty(INT_ARRAY));

When we run the test, we have a compiler error:

java: method isArrayNullOrEmpty in class ... cannot be applied to given types;
  required: T[]
  found:    int[]
  reason: inference variable T has incompatible bounds 

This is because Java generics are implemented using “type erasure” for backward compatibility. All generic types are converted to Object at runtime. However, primitive types don’t inherit from Object. Therefore, generics don’t work with primitive types.

So, to make our method support all primitive type arrays, we can overload the method and use the same implementation but accept different primitive types as the parameter. 

Let’s take the generic isArrayNullOrEmpty() method as an example to see how to do it:

static boolean isArrayNullOrEmpty(int[] theArray) {
    return theArray == null || theArray.length == 0;
}
static boolean isArrayNullOrEmpty(short[] theArray) { /* the same implementation */ }
static boolean isArrayNullOrEmpty(long[] theArray) { /* the same implementation */ }
// ... same for float, double, byte, boolean primitive type arrays

Now, if we perform the check for primitive type arrays:

assertFalse(isArrayNullOrEmpty(INT_ARRAY));

The code compiles and the test passes.

5. Using the ArrayUtils.isEmpty() Method

Apache Commons Lang 3 is a widely used library. Its ArrayUtils class provides a rich set of utilities, making array manipulation easier. The class offers an isEmpty() method to check whether an array is null or empty.

To use the ArrayUtils class, we must first add the Apache Commons Lang 3 dependency to our pom.xml:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>

Then, we can use the isEmpty() method in our code:

assertTrue(ArrayUtils.isEmpty(NULL_ARRAY));
assertTrue(ArrayUtils.isEmpty(EMPTY_ARRAY));
assertFalse(ArrayUtils.isEmpty(STR_ARRAY));
//primitive array
assertFalse(ArrayUtils.isEmpty(INT_ARRAY));

It’s worth noting that ArrayUtils also defines a set of isEmpty() methods, one takes Object[] as the parameter, and the rest accept parameters in each primitive type:

public static boolean isEmpty(final Object[] array)
public static boolean isEmpty(final short[] array)
public static boolean isEmpty(final int[] array)
public static boolean isEmpty(final long[] array)
// ... other primitive types

Therefore, ArrayUtils.isEmpty() can check our int[] array without error.

6. Using the ObjectUtils.isEmpty() Method

ObjectUtils from Apache Commons Lang 3 aims to handle null objects gracefully. When we pass an array to the ObjectUtils.isEmpty() method, it can also report if the array is null or empty:

assertTrue(ObjectUtils.isEmpty(NULL_ARRAY));
assertTrue(ObjectUtils.isEmpty(EMPTY_ARRAY));
assertFalse(ObjectUtils.isEmpty(STR_ARRAY));
//primitive array
assertFalse(ObjectUtils.isEmpty(INT_ARRAY));

As the test shows, it works for object and primitive type arrays. Unlike ArrayUtils.isEmpty(), ObjectUtils doesn’t have isEmpty() methods for each primitive type. Instead, isEmpty() accepts an Object as the parameter and checks if it’s an array:

public static boolean isEmpty(final Object object) {
    if (object == null) {
        return true;
    }
  
    if (isArray(object)) {
        return Array.getLength(object) == 0;
    }
    // ... unrelated code omitted
    return false;
}

public static boolean isArray(final Object object) {
    return object != null && object.getClass().isArray();
}

Since primitiveArray.getClass().isArray() is true, isEmpty() works for primitive type arrays.

7. Conclusion

Checking if an array is null or empty is a fundamental task in Java programming. In this article, we’ve explored how to implement these checks for both object and primitive type arrays, creating a robust utility method that can be reused in our applications. Additionally, we’ve demonstrated how to use the convenient ArrayUtils.isEmpty() and ObjectUtils.isEmpty() to do the job.

Following these practices, we can write cleaner, safer, and more reliable Java code.