Java Arrays - Complete Guide

1. Introduction to Java Arrays

An array stores multiple values of the same type in contiguous memory. Array length is fixed after creation and indexed from zero.

• Fixed size once created
• Zero-based indexing
• Length property, not method
• Reference type stored on heap

public class ArrayIntro {
    public static void main(String[] args) {
        int[] scores = {90, 85, 78};
        System.out.println(scores[0]);
        System.out.println(scores.length);
    }
}

2. Initialization, Storing, and Accessing

An array variable holds a reference to an array object on the heap. Elements are stored in indexed slots starting at 0.

Ways to initialize arrays

Storing and accessing values

• Store: arr[index] = value;
• Read: value = arr[index];
• 2D: matrix[row][col] — row first, then column
• Length: arr.length (1D) or matrix.length / matrix[i].length (2D)

public class InitAccess {
    public static void main(String[] args) {
        // 1D: literal init
        int[] marks = {78, 92, 85};

        // 1D: allocate then store
        String[] names = new String[2];
        names[0] = "Asha";
        names[1] = "Ravi";

        // Access
        System.out.println(marks[1]);      // 92
        marks[2] = 88;                     // update

        // 2D: store and access
        int[][] seats = new int[2][3];
        seats[0][0] = 101;
        seats[1][2] = 203;
        System.out.println(seats[1][2]);   // 203
    }
}

3. One-Dimensional Arrays — Applications

A 1D array is a single row of values. Use it when data is a sequence of the same type.

public class OneDApp {
    public static void main(String[] args) {
        int[] marks = {78, 92, 85, 60};
        int max = marks[0];
        for (int i = 1; i < marks.length; i++) {
            if (marks[i] > max) max = marks[i];
        }
        System.out.println("Highest mark: " + max);
    }
}

4. Two-Dimensional Arrays — Applications

A 2D array is an array of arrays — think rows and columns. Access with matrix[row][col].

public class TwoDApp {
    public static void main(String[] args) {
        // 3 students, 2 subjects (Math, Science)
        int[][] marks = {
            {78, 85},
            {92, 88},
            {60, 72}
        };
        int student = 1, subject = 0;
        System.out.println("Student 2 Math: " + marks[student][subject]);

        for (int r = 0; r < marks.length; r++) {
            for (int c = 0; c < marks[r].length; c++) {
                System.out.print(marks[r][c] + "\t");
            }
            System.out.println();
        }
    }
}

5. Array Operations and Time Complexity

Common operations on arrays and their typical time complexity (n = number of elements; for 2D, n ≈ rows × columns).

import java.util.Arrays;

public class ArrayOps {
    public static void main(String[] args) {
        int[] data = {40, 10, 30, 20};

        // Traverse + sum — O(n)
        int sum = 0;
        for (int x : data) sum += x;

        // Linear search — O(n)
        int target = 30, index = -1;
        for (int i = 0; i < data.length; i++) {
            if (data[i] == target) { index = i; break; }
        }

        // Sort — O(n log n)
        Arrays.sort(data);

        System.out.println("Sum: " + sum + ", index of 30: " + index);
        System.out.println(Arrays.toString(data));
    }
}

6. Jagged Arrays — Why Use Them?

In Java, a 2D array is really an array of row arrays. A jagged array has rows of different lengths — not a perfect rectangle.

Why jagged arrays?

• Save memory — no wasted slots when each row needs a different size
• Real data is uneven — students take different numbers of optional subjects; a triangle of numbers has 1, then 2, then 3 elements per row
• Sparse tables — most rows are short; only some rows are long
• Flexibility — each row is its own int[] object on the heap

public class JaggedArray {
    public static void main(String[] args) {
        int[][] triangle = new int[4][];  // 4 rows, lengths assigned later
        for (int r = 0; r < triangle.length; r++) {
            triangle[r] = new int[r + 1];  // row r has (r+1) elements
            for (int c = 0; c < triangle[r].length; c++) {
                triangle[r][c] = r + c;
            }
        }
        System.out.println("Row 2 length: " + triangle[2].length);  // 3
    }
}

7. Three-Dimensional Arrays — Why and Where Used?

A 3D array adds one more index: arr[depth][row][col] or arr[x][y][z]. It is an array of 2D arrays (or array of arrays of arrays).

Why 3D arrays?

• Model data that has three natural dimensions (not just rows and columns)
• Keep related values together in one structure instead of many separate 2D arrays
• Useful in graphics, simulation, and scientific code where a “cube” of values is natural

Where 3D arrays are used

public class ThreeDArray {
    public static void main(String[] args) {
        // 2 batches, 2 students each, 3 subjects
        int[][][] marks = {
            { {78, 85, 90}, {92, 88, 80} },   // batch 0
            { {70, 75, 72}, {65, 68, 70} }    // batch 1
        };
        int batch = 0, student = 1, subject = 2;
        System.out.println("Batch 1, Student 2, Subject 3: "
            + marks[batch][student][subject]);  // 80

        // Allocate explicitly: 2 floors, 3 rows, 4 seats
        boolean[][][] seats = new boolean[2][3][4];
        seats[0][1][2] = true;  // floor 0, row 1, seat 2 booked
    }
}

8. Array Best Practices

Arrays are fast but fixed-size. Modern Java often prefers ArrayList for dynamic collections while arrays remain essential for performance-critical code.

• Check bounds before accessing index
• Use Arrays.copyOf instead of manual copy
• Prefer List when size changes often
• Use enhanced for to avoid index errors
• Consider Arrays.stream for processing