Remove All Elements From a String Array in Java

1. Overview

In Java, working with arrays is a common task when dealing with collections of data. Sometimes, we may find ourselves in situations where we need to remove all elements from a String array. This task is straightforward, though it requires us to consider how arrays work in Java.

In this quick tutorial, let’s explore how to remove all elements from a String array.

2. Introduction to the Problem

Removing all elements from an array can be helpful in cleaning up data or resetting the array for new input. Before we dive into the implementations, let’s quickly understand how arrays work in Java.

Arrays in Java are fixed in size. In other words, once we create an array, we cannot change its length. This characteristic impacts how we handle operations like “removing” or “inserting” elements, which is not as simple as in Collections like ArrayList.

When we talk about removing all elements from a String array, we have two options:

• Reinitialize a new array (Depending on the requirement, the new array can be empty or the same size.)
• Reset all elements in the array to null values.

Next, let’s take a closer at these two approaches. For simplicity, we’ll leverage unit test assertions to verify if each approach works as expected.

3. Non-Final Array Variable: Reinitializing and Reassignment

The idea of this approach is pretty straightforward. Let’s say we have one array variable, myArray, containing some elements. To empty myArray, we can reinitialize an empty array and reassign it to the myArray variable.

Next, let’s understand how it works through an example:

String[] myArray1 = new String[] { "Java", "Kotlin", "Ruby", "Go", "C#", "C++" };
myArray1 = new String[0];
assertEquals(0, myArray1.length);

In this example, we’re creating a new array of size 0 and assigning it back to myArray1. This effectively removes all elements by creating an entirely new, empty array.

Sometimes, we want the new array to have the same length as the original one. In this case, we can initialize the new array with the desired size:

static final String[] SIX_NULL_ARRAY = new String[] { null, null, null, null, null, null };
 
String[] myArray2 = new String[] { "Arch Linux", "Debian", "CentOS", "Gentoo", "Fedora", "Redhat" };
myArray2 = new String[myArray2.length];
assertArrayEquals(SIX_NULL_ARRAY, myArray2);

As the test shows, the new array has the same size (6) as the original one, and all elements are null values.

Removing all elements by reinitializing and reassignment is straightforward. This approach is useful if we want to completely reset the array and potentially use a different size. However, since we need to assign the new array back to the same variable, this approach works only if the array variable isn’t final.

Next, let’s explore how to remove all array elements if the array variable is declared as final.

4. Resetting All Elements to null

We’ve mentioned that arrays in Java are fixed in size. That is to say, when an array has been initialized and assigned to a final variable, we cannot remove its elements to get an empty array (length=0).

One approach to “removing” elements from an array is to set each element to null. This method doesn’t change the array’s size but effectively clears its content.

Next, let’s check an example:

final String[] myArray = new String[] { "A", "B", "C", "D", "E", "F" };
for (int i = 0; i < myArray.length; i++) {
    myArray[i] = null;
}
assertArrayEquals(SIX_NULL_ARRAY, myArray);

As the above example shows, we loop through myArray and assign a null to each element. After running the loop, the array myArray will still have the same length, but all its elements will be null.

5. Using the Arrays.fill() Method

Java’s Arrays class provides a convenient fill() method that allows us to set all elements of an array to a specific value. We can use this method to set all elements to null, similar to the resetting in loop approach, but with less code:

final String[] myArray = new String[] { "a", "b", "c", "d", "e", "f" };
Arrays.fill(myArray, null);
assertArrayEquals(SIX_NULL_ARRAY, myArray);

As we can see, using the Arrays.fill() method, we can achieve array resetting with a single line of code, making it more concise.

6. Conclusion

Removing all elements from an array in Java is a common task when working with arrays, and it can be done in several ways.

In this article, we’ve explored three different approaches to achieve that through examples:

• Reinitializing the array – This is ideal when we want to start fresh with a new array, possibly of a different size. However, it only works for non-final array variables.
• Resetting to null – This is appropriate to clear the content but maintain the array size for future use.
• Using Arrays.fill() – A clean and concise way to reset all elements when maintaining array size.

By understanding the available options, we can choose the best approach for our specific situation, ensuring our code is efficient and clear.