how to empty an array in java

HaC 2025

3 min read 18-03-2025

Arrays in Java are fixed-size data structures. This means you can't directly "empty" an array like you might with a dynamically sized collection like an ArrayList. However, there are several ways to achieve the effect of emptying an array, depending on what you want to accomplish.

Methods for "Emptying" a Java Array

The term "emptying" an array in Java is a bit of a misnomer. Since arrays have a fixed size, you can't actually reduce their size to zero. Instead, we focus on methods that render the array effectively unusable or reset its contents.

1. Re-initializing the Array

The simplest approach is to create a new, empty array of the same type and size. This effectively replaces the old array. Note this uses more memory than other methods.

public class EmptyArray {
    public static void main(String[] args) {
        int[] myArray = {1, 2, 3, 4, 5};

        // Re-initialize the array
        myArray = new int[myArray.length]; //Creates a new array with same length, but all values are 0

        //Check if the array is empty (all values are 0 in this case)
        for (int i = 0; i < myArray.length; i++) {
            System.out.println(myArray[i]);
        }
    }
}

2. Filling the Array with Default Values

Instead of creating a new array, you can overwrite the existing elements with default values. For numeric types, this would be 0; for booleans, it's `false`; and for objects, it's `null`.

public class EmptyArray {
    public static void main(String[] args) {
        int[] myArray = {1, 2, 3, 4, 5};

        // Fill the array with default values (0 for integers)
        java.util.Arrays.fill(myArray, 0);

        // Check if the array is "empty" (filled with zeros)
        for (int i = 0; i < myArray.length; i++) {
            System.out.println(myArray[i]);
        }
    }
}

This method is more memory efficient than completely re-initializing the array. It's also potentially faster because it avoids the overhead of creating a new array.

3. Using `Arrays.copyOf` for a new array with a specified size:

This is similar to re-initialization but gives you more control. You can create a completely empty array of a different size if needed.

public class EmptyArray {
    public static void main(String[] args) {
        int[] myArray = {1, 2, 3, 4, 5};

        // Create a new empty array (size 0)
        myArray = java.util.Arrays.copyOf(myArray, 0);  

        //Check the length (should be 0)
        System.out.println(myArray.length);
    }
}

This method allows you to effectively create an "empty" array by specifying a size of 0. Note this creates a new array completely.

4. Using a List (for dynamic resizing)

If you need a data structure that can truly be emptied and resized dynamically, consider using a `java.util.ArrayList` instead of an array. `ArrayLists` provide methods like `clear()` to easily remove all elements.

import java.util.ArrayList;
import java.util.List;

public class EmptyArrayList {
    public static void main(String[] args) {
        List<Integer> myList = new ArrayList<>(List.of(1, 2, 3, 4, 5));

        myList.clear(); // Empties the ArrayList

        System.out.println(myList.size()); // Prints 0
    }
}

This is a more flexible approach if your requirement involves dynamic sizing and easy emptying.

Choosing the Right Method

The best method for "emptying" a Java array depends on your specific needs:

Re-initialization: Simplest but least memory-efficient. Useful if you need a completely fresh array.
Filling with default values: More memory-efficient than re-initialization. Suitable when you want to reuse the existing array.
Arrays.copyOf: Gives you full control over the new array size.
Using ArrayList: Best for dynamic resizing and easy emptying; a fundamentally different approach.

Remember to choose the method that balances efficiency and your application's requirements. For situations requiring dynamic resizing, using ArrayList is generally the superior choice. For fixed-size arrays where only the content matters, filling with default values or using Arrays.copyOf is often preferred.