Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW