One-Dimensional Arrays

An array is a fundamental container in Java designed to store multiple values of a single data type. Once initialized, its length is fixed, providing a high-performance way to manage ordered data.

Static Initialization

Static initialization is used when the exact values of the array elements are known at the time of creation. This process allocates memory and populates the container simultaneously.

Syntax Options:

• Standard approach: type[] identifier = new type[]{val1, val2, val3};
• Shorthand approach: type[] identifier = {val1, val2, val3};

// Example of static initialization
double[] priceList = {19.99, 25.50, 9.95, 42.00};

Declaring Array Variables

There are two syntactically valid ways to declare an array variable, though the first is generally preferred in Java development:

1. int[] measurements; (Preferred)
2. int measurements[];

Element Access and Indexing

Array elements are accessed via a zero-based index. For an array of size N, the valid indices range from 0 to N-1.

String[] nodes = {"Alpha", "Beta", "Gamma"};
System.out.println(nodes[1]); // Output: Beta

Iterating Through Arrays

While manual access is possible for small datasets, standard practice involves using loops combined with the .length property to ensure dynamic scaling.

int[] sequence = {10, 20, 30, 40, 50};

for (int index = 0; index < sequence.length; index++) {
    int value = sequence[index];
    System.out.println("Element at index " + index + ": " + value);
}

Dynamic Initialization

When the specific data is unknown at declaration, dynamic initialization allows for pre-allocating a specific size. The JVM assigns default values (e.g., 0 for numeric types, false for booleans, and null for objects).

Syntax: type[] identifier = new type[size];

// Allocating space for 10 integers
int[] observationData = new int[10];

Common Pitfalls: NullPointerExceptions

A NullPointerException occurs when an array reference variable is set to null, severing its connection to any object in the heap memory. Any subsequent attempt to access indices or properties (like .length) will crash the program.

int[] buffer = new int[5];
buffer = null;
// The following line would trigger an exception:
// int firstElement = buffer[0]; 

Multi-Dimensional Arrays

A two-dimensional array in Java is essentially an "array of arrays." This structure is ideal for representing grids, matrices, or grouped datasets.

Static Initialization of 2D Arrays

You can define a 2D array by nesting curly braces to represent the rows and columns.

// Standard syntax
int[][] matrix = new int[][]{{1, 2}, {3, 4}};

// Simplified syntax
int[][] coordinateMap = {
    {10, 20, 30},
    {40, 50, 60},
    {70, 80, 90}
};

Nested Iteration

To process every element in a 2D array, nested loop are required. The outer loop traversse the rows (the nested arrays), while the inner loop traverses the elements within those rows.

public static void processGrid(int[][] grid) {
    for (int row = 0; row < grid.length; row++) {
        for (int col = 0; col < grid[row].length; col++) {
            int cellValue = grid[row][col];
            System.out.print(cellValue + " ");
        }
        System.out.println(); // New line after each row
    }
}

Dynamic Initialization of 2D Arrays

When initializing dynamically, you specify the number of sub-arrays and, optionally, the size of those sub-arrays.

Syntax: type[][] identifier = new type[rowCount][columnCount];

// Creates a grid with 5 rows and 3 columns
int[][] sensorGrid = new int[5][3];

// Java also supports 'jagged' arrays where inner arrays have different lengths
int[][] jaggedTable = new int[3][];
jaggedTable[0] = new int[2];
jaggedTable[1] = new int[5];
jaggedTable[2] = new int[1];