Can The Size Of An Array Be Declared At Runtime In Java Program

In Java, the perceived limitation of arrays being fixed-size at compile time can be overcome. In this article, you will learn how to dynamically declare array sizes at runtime in Java programs, adapting to varying data requirements or user input.

Problem Statement

Traditional array declaration in Java often involves specifying a fixed size at compile time, such as int[] numbers = new int[10];. This approach poses a significant challenge when the exact number of elements is unknown until the program executes. For instance, if a program needs to store user-provided data, or process a variable number of records from a file or network, a fixed-size array declared beforehand can lead to either wasted memory (too large) or ArrayIndexOutOfBoundsException errors (too small). The core problem is the inability to adapt array capacity to runtime conditions.

Example

Consider a scenario where you want to create an array to store marks, but the number of students is only known when the program runs. Directly using an undefined variable for size at compile time would result in an error. A simple fixed-size array might look like this, which isn't flexible:

// FixedSizeArrayExample
public class Main {
    public static void main(String[] args) {
        // Step 1: Declare a fixed-size array
        int[] fixedMarks = new int[5]; // Only 5 students can be stored

        // Step 2: Attempt to store more data than capacity (conceptual issue)
        // If there were 7 students, this array wouldn't be sufficient.
        System.out.println("Fixed-size array created for 5 marks.");
    }
}

Run

The output for this program simply confirms the creation, but it highlights the inflexibility:

Fixed-size array created for 5 marks.

Background & Knowledge Prerequisites

To understand runtime array declaration, readers should be familiar with:

• Java Basics: Variables, data types, basic input/output.
• Array Fundamentals: How arrays are declared, initialized, and accessed.
• java.util.Scanner: For reading input from the console.
• Loops: For iterating over arrays or processing data to determine size.

Use Cases or Case Studies

Declaring array sizes at runtime is crucial in several practical scenarios:

• User Input-Driven Applications: When the number of items or records to be processed is determined by the user at the time of program execution (e.g., "How many numbers do you want to enter?").
• Data Processing with Unknown Volumes: Reading an unspecified number of lines from a file, rows from a database query, or packets from a network stream, where the total count is only known after initial processing.
• Dynamic Algorithm Results: Algorithms that produce a variable number of results based on their input, requiring an array to store these results without pre-determining its exact size.
• Memory-Efficient Resource Allocation: Allocating array memory precisely to what's needed, avoiding over-allocation or under-allocation, which is important in resource-constrained environments.
• Application Configuration: Where array dimensions or capacities are read from configuration files or environment variables at startup.

Solution Approaches

Java provides straightforward ways to declare array sizes at runtime using variables that hold values determined during execution.

Approach 1: Determining Size from User Input (Using Scanner)

This is the most common way to let the user dictate the array's size.

• Summary: Prompt the user to enter the desired array size and use that input to declare the array.

// DynamicArraySizeFromUserInput
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Step 1: Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Step 2: Prompt the user for the array size
        System.out.print("Enter the desired size of the array: ");

        // Step 3: Read the integer input from the user
        int arraySize = scanner.nextInt();

        // Step 4: Declare the array with the user-provided size
        int[] numbers = new int[arraySize];

        // Step 5: Inform the user and populate the array (optional, for demonstration)
        System.out.println("Array of size " + numbers.length + " created successfully.");
        System.out.println("Please enter " + numbers.length + " integer elements:");

        for (int i = 0; i < numbers.length; i++) {
            System.out.print("Enter element " + (i + 1) + ": ");
            numbers[i] = scanner.nextInt();
        }

        // Step 6: Print the elements to verify
        System.out.print("The elements in the array are: ");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + (i == numbers.length - 1 ? "" : ", "));
        }
        System.out.println();

        // Step 7: Close the scanner to prevent resource leaks
        scanner.close();
    }
}

Run

• Sample Output:

Enter the desired size of the array: 3
Array of size 3 created successfully.
Please enter 3 integer elements:
Enter element 1: 10
Enter element 2: 20
Enter element 3: 30
The elements in the array are: 10, 20, 30

• Stepwise Explanation:

1. An instance of Scanner is created to handle input from the standard input stream (System.in).
2. The program prompts the user to enter a number for the array's size.
3. scanner.nextInt() reads the integer value entered by the user and stores it in the arraySize variable.
4. The array numbers is then declared using new int[arraySize]. At this point, arraySize holds the value determined at runtime, making the array's size dynamic.
5. The remaining steps demonstrate populating and printing the array, proving its runtime-defined size.
6. The Scanner resource is closed.

Approach 2: Determining Size from a Variable Calculated at Runtime

This approach uses a variable whose value is computed during program execution based on other data or logic, not directly from user input.

• Summary: Perform a calculation or data processing at runtime to determine the final size, then use this computed value to declare the array.

// DynamicArraySizeFromCalculation
public class Main {
    public static void main(String[] args) {
        // Step 1: Simulate a runtime calculation to determine array size
        // For example, finding the count of even numbers in a predefined list.
        int[] sourceData = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int evenCount = 0;

        for (int number : sourceData) {
            if (number % 2 == 0) {
                evenCount++;
            }
        }

        // Step 2: Use the calculated count to declare the array
        int[] evenNumbers = new int[evenCount];

        // Step 3: Populate the new array (optional, for demonstration)
        int index = 0;
        for (int number : sourceData) {
            if (number % 2 == 0) {
                evenNumbers[index] = number;
                index++;
            }
        }

        // Step 4: Print the elements to verify
        System.out.println("Array of size " + evenNumbers.length + " created based on calculation.");
        System.out.print("Even numbers found: ");
        for (int i = 0; i < evenNumbers.length; i++) {
            System.out.print(evenNumbers[i] + (i == evenNumbers.length - 1 ? "" : ", "));
        }
        System.out.println();
    }
}

Run

• Sample Output:

Array of size 5 created based on calculation.
Even numbers found: 2, 4, 6, 8, 10

• Stepwise Explanation:

1. The evenCount variable is initialized and then populated by iterating through sourceData at runtime, incrementing for each even number found.
2. After the loop completes, evenCount holds the exact number of even elements.
3. This evenCount variable is then used to declare the evenNumbers array. The array's size is thus determined dynamically based on the preceding calculation.
4. The new array is populated and its contents are printed.

Approach 3: Using Command-Line Arguments for Size

Command-line arguments allow passing values to a Java program when it's executed, which can include the desired array size.

• Summary: Retrieve the array size from the args array passed to the main method.

// DynamicArraySizeFromCLI
public class Main {
    public static void main(String[] args) {
        // Step 1: Check if a command-line argument for size is provided
        if (args.length == 0) {
            System.out.println("Usage: java Main <array_size>");
            return;
        }

        // Step 2: Parse the first command-line argument as the array size
        int arraySize = 0;
        try {
            arraySize = Integer.parseInt(args[0]);
        } catch (NumberFormatException e) {
            System.out.println("Invalid array size provided. Please enter an integer.");
            return;
        }

        // Step 3: Ensure the size is non-negative
        if (arraySize < 0) {
            System.out.println("Array size cannot be negative.");
            return;
        }

        // Step 4: Declare the array with the command-line provided size
        int[] data = new int[arraySize];

        // Step 5: Inform the user (optional, for demonstration)
        System.out.println("Array of size " + data.length + " created from command-line argument.");

        // Step 6: Initialize elements (optional)
        for (int i = 0; i < data.length; i++) {
            data[i] = i * 10;
        }

        // Step 7: Print the elements
        System.out.print("Array elements: ");
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + (i == data.length - 1 ? "" : ", "));
        }
        System.out.println();
    }
}

Run

• Sample Output (running from terminal):

• Compilation: javac Main.java
• Execution: java Main 4

Array of size 4 created from command-line argument.
    Array elements: 0, 10, 20, 30

• Execution (without argument): java Main

Usage: java Main <array_size>

• Explanation:

1. The args parameter of the main method receives command-line arguments as an array of strings.
2. The first argument (args[0]) is parsed into an integer arraySize. Error handling is included for cases where no argument is given or the argument is not a valid integer.
3. This arraySize is then used to declare the data array.

Conclusion

While Java arrays are inherently fixed in size *after* their declaration, their initial size *can* be determined dynamically at runtime. This flexibility is achieved by using variables that store values obtained during program execution, whether through user input, calculations based on processed data, or command-line arguments. This approach allows Java programs to create arrays that adapt precisely to the requirements of the moment, making them more robust and efficient. For scenarios where the collection's size needs to change *after* initial creation (growing or shrinking), java.util.ArrayList or other dynamic collections are generally preferred.

Summary

• Java arrays have a fixed size once they are declared.
• The size of an array can be determined and set at runtime.
• This is achieved by using a variable whose value is obtained during program execution.
• Common methods for determining array size at runtime include:
• Reading user input via java.util.Scanner.
• Performing calculations based on other runtime data or logic.
• Parsing command-line arguments.
• For collections that need to dynamically change size *after* creation, java.util.ArrayList is the standard and more flexible solution.