What is the explicit creation of an array in Java?

In Java, the explicit creation of an array refers to the process of declaring and instantiating an array using the new keyword, specifying both the data type of the elements it will hold and its size. This contrasts with implicit array creation, where the array is created and initialized based on the provided values without explicitly defining its size using new.

Here's a breakdown of the explicit array creation process:

1. Declaration: First, you declare the array variable, specifying the data type of the elements followed by square brackets [] and the array name. For example:

int[] myArray;

This declaration tells the Java compiler that myArray is a variable that will hold a reference to an array of integers. At this point, no memory has been allocated for the array.

2. Instantiation: Next, you use the new keyword to allocate memory for the array and specify its size. This involves specifying the data type and the number of elements the array can hold within the square brackets. For example:

myArray = new int[10];

This statement creates an array that can hold 10 integer values. The new int[10] expression allocates memory for the array, and then assigns the reference of that memory location to the myArray variable.

3. Initialization (Optional): After instantiation, the elements of the array are automatically initialized with default values based on their data type. For example, integer array elements are initialized to 0, boolean elements to false, and object references to null. You can then explicitly assign values to each element of the array.

myArray[0] = 15;
myArray[1] = 25;
// ... and so on

A complete example:

public class ExplicitArrayCreation {
  public static void main(String[] args) {
    // Declaration and instantiation
    int[] numbers = new int[5];

    // Initialization
    numbers[0] = 10;
    numbers[1] = 20;
    numbers[2] = 30;
    numbers[3] = 40;
    numbers[4] = 50;

    // Printing the array elements
    for (int i = 0; i < numbers.length; i++) {
      System.out.println("Element at index " + i + ": " + numbers[i]);
    }
  }
}

In summary, explicit array creation in Java involves using the new keyword to define the size of the array, allocating memory, and optionally initializing the array elements. This approach offers more control over array creation and is essential when the size of the array is known beforehand.

Learn more about this