Java Arrays and Multidimensional Arrays

An array groups positions under one name

Suppose a learner has three scores. Separate variables such as scoreOne, scoreTwo, and scoreThree make it awkward to repeat the same operation for every score. An int[] gives those values one array name and an indexed position for each element. Every element in this example stores an int.

The initializer {64, 78, 91} creates a three-element array. Position 0 contains 64, position 1 contains 78, and position 2 contains 91. Read scores[1] as the element at index 1, which is the second element, not the first. Using a zero-based position consistently is more important than memorizing one example.

An array object's length is fixed after creation, but its elements can change. Assigning scores[1] = 82 replaces that stored value without creating a fourth position or moving the other entries. If an application needs a growing collection, ArrayList will be a later topic; an array does not gain an element simply by assigning beyond its bounds.

public class Main {
    public static void main(String[] args) {
        int[] scores = {64, 78, 91};
        System.out.println("Length: " + scores.length);
        System.out.println("First score: " + scores[0]);
        scores[1] = 82;
        System.out.println("Updated second score: " + scores[1]);
        System.out.println("Last score: " + scores[scores.length - 1]);
    }
}

Select Run code to compile and execute this program.

Length: 3
First score: 64
Updated second score: 82
Last score: 91

Creating an array is different from declaring its variable

Use an initializer when the initial values are known. Use new int[3] when you need three positions whose values will be assigned later. Writing only int[] attempts declares a local reference variable; it does not create an array. Java will reject reading that local variable before it has been assigned.

A newly created array initializes its elements according to their type. int elements start at 0, boolean elements at false, and reference elements such as String at null. These element defaults do not give an unassigned local variable a usable array automatically. A default zero is also not proof that a learner actually submitted a zero score.

new String[2] creates the array, not two text values. Calling a method on an unassigned null element can fail even when the array itself exists. Assign meaningful data before using it. For a later assignment to an existing variable, write names = new String[] {"Mina", "Leo"}; rather than a bare brace initializer on its own.

public class Main {
    public static void main(String[] args) {
        int[] attempts = new int[3];
        boolean[] completed = new boolean[2];
        String[] names = new String[2];
        System.out.println("Default attempts: " + attempts[0]);
        System.out.println("Default completed: " + completed[0]);
        System.out.println("Default name: " + names[0]);
        attempts[2] = 4;
        names[0] = "Mina";
        System.out.println("Assigned name: " + names[0]);
        System.out.println("Third attempt count: " + attempts[2]);
    }
}

Select Run code to compile and execute this program.

Default attempts: 0
Default completed: false
Default name: null
Assigned name: Mina
Third attempt count: 4

length is a count; the last valid index is length minus one

For an array of length three, the valid indexes are 0, 1, and 2. The expression scores[scores.length - 1] reads the last element only when at least one element exists. There is no element at index scores.length. A negative index is invalid as well.

An indexed traversal normally uses index = 0 with index < scores.length. Using <= eventually attempts one access beyond the end and throws ArrayIndexOutOfBoundsException. Java checks these accesses at runtime; a program may compile successfully and still fail for an empty array or an incorrect boundary.

The length member has no parentheses: scores.length. This differs from the String method name.length(). An array's length cannot be assigned a new value. To work with a different length, create another array and, when needed, copy the existing values. Also validate a dynamic requested size before creating an array; a negative size is not allowed.

Read values with enhanced for; write positions deliberately

Enhanced for is convenient for totals and checks that only need the current value. With a primitive int array, the local loop variable receives a copy of each element's value. Adding five to that local variable does not write the new number back into its source position.

The first traversal in this program therefore leaves the array unchanged. The indexed traversal explicitly assigns to scores[index], which changes the stored element. Both loops visit the same starting values, but the left-hand side of the assignment determines whether array storage is actually updated.

Keep the operation's intent visible. Use enhanced for when reading is enough; use an index when a position, replacement, reverse direction, or stride matters. Arrays.toString formats the elements for inspection. Printing an array reference directly is not a useful way to check whether its values changed.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] scores = {40, 65, 90};
        for (int score : scores) {
            score += 5;
        }
        System.out.println("After local changes: " + Arrays.toString(scores));
        for (int index = 0; index < scores.length; index++) {
            scores[index] += 5;
        }
        System.out.println("After element changes: " + Arrays.toString(scores));
    }
}

Select Run code to compile and execute this program.

After local changes: [40, 65, 90]
After element changes: [45, 70, 95]

A summary needs an empty case and a valid starting value

The readings example deliberately uses negative values. If highest started at zero, the result would incorrectly claim a highest reading of 0 even though 0 does not occur in the data. After checking that the array is nonempty, seed highest from the first actual element instead.

The loop adds every reading to total and updates highest only when it encounters a larger value. A long total gives more room than an int sum. The cast before division makes the average floating-point rather than truncated integer arithmetic. Formatting rounds the displayed result; it does not change the underlying calculation.

An empty array has no first value and no arithmetic mean to report. Handle that case before reading index 0 or dividing by length. The early return prints a missing-result message instead of inventing a maximum of zero or trying to compute an average with no observations.

import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        int[] readings = {-8, -3, -11};
        if (readings.length == 0) {
            System.out.println("No readings available.");
            return;
        }
        long total = 0;
        int highest = readings[0];
        for (int reading : readings) {
            total += reading;
            if (reading > highest) {
                highest = reading;
            }
        }
        double average = (double) total / readings.length;
        System.out.println("Highest: " + highest);
        System.out.printf(Locale.ROOT, "Average: %.2f%n", average);
    }
}

Select Run code to compile and execute this program.

Highest: -3
Average: -7.33

Empty, missing, and unassigned are three different states

An empty array is a real array with length 0. It can be traversed safely because the body runs zero times, but it has no readable first or last element. A null reference means there is no array object to inspect, so even reading its length would fail without a guard.

The combined guard uses missing == null || missing.length == 0. Because || short-circuits, Java does not evaluate the length access when the null comparison is true. Reversing those checks would attempt the unsafe access first. A local variable that has never been assigned is different again: Java reports a compile-time definite-assignment error when it is read.

Whether empty and missing mean the same thing is an application policy. A recorded session containing zero scores may be a valid empty collection; a missing session may mean it was never supplied. The lab keeps these row states distinct rather than silently converting a missing row into an observed zero score.

public class Main {
    public static void main(String[] args) {
        int[] empty = {};
        int[] missing = null;
        System.out.println("Empty length: " + empty.length);
        if (missing == null || missing.length == 0) {
            System.out.println("No readable first element.");
        }
        for (int value : empty) {
            System.out.println("This value would print: " + value);
        }
        System.out.println("Empty traversal finished.");
    }
}

Select Run code to compile and execute this program.

Empty length: 0
No readable first element.
Empty traversal finished.

Assignment shares an array; a copy creates different storage

An array variable holds a reference to an array object. int[] alias = original copies that reference, not the elements. Both variables then identify the same storage, so changing alias[0] also changes the value observed through original[0]. The array did not synchronize two independent copies; there was only one array to begin with.

Arrays.copyOf(original, original.length) creates another one-dimensional int array and copies the values. Changes to that snapshot do not change the original primitive elements. Reassigning a variable to a different array also does not redirect aliases that still refer to the old object.

Copying with a larger requested length creates additional default-initialized positions; copying with a smaller length keeps only the leading values that fit. It does not resize the old object. Similarly, final int[] prevents reassignment of that reference variable, but does not make the referenced elements immutable.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] original = {10, 20};
        int[] alias = original;
        int[] snapshot = Arrays.copyOf(original, original.length);
        alias[0] = 99;
        snapshot[1] = 77;
        System.out.println("Original: " + Arrays.toString(original));
        System.out.println("Alias: " + Arrays.toString(alias));
        System.out.println("Snapshot: " + Arrays.toString(snapshot));
        System.out.println("Original and alias share: " + (original == alias));
    }
}

Select Run code to compile and execute this program.

Original: [99, 20]
Alias: [99, 20]
Snapshot: [10, 77]
Original and alias share: true

Use content-aware tools to print and compare

For arrays, == asks whether two references identify the same array object. It does not compare the sequence of values. Two separately created arrays can therefore print Same reference: false even when both contain 10 followed by 20.

Arrays.equals compares the contents of these one-dimensional int arrays in order. Arrays.toString gives a readable representation such as [10, 20]. Both helpers belong to java.util.Arrays, which this example imports. Neither operation changes the input arrays.

For nested arrays, Arrays.deepToString produces readable row contents and Arrays.deepEquals compares nested contents. Ordinary Arrays.equals on an int[][] compares its row references rather than recursively comparing the numbers. Content equality is also separate from whether later mutations through shared rows can affect both structures.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] first = {10, 20};
        int[] second = {10, 20};
        System.out.println("Same reference: " + (first == second));
        System.out.println("Same contents: " + Arrays.equals(first, second));
        System.out.println("Values: " + Arrays.toString(first));
    }
}

Select Run code to compile and execute this program.

Same reference: false
Same contents: true
Values: [10, 20]

A two-dimensional array is an array of row references

Read int[][] as an array whose elements are themselves int arrays. In minutes[row][column], the first index selects a row array, then the second index selects an element within that row. minutes.length counts rows; minutes[row].length counts elements in one selected row.

The rectangular example has two rows of three entries. minutes[1][2] selects the second row's third entry, 35. The outer loop selects each row, and the inner loop adds that row's values. total is reset for each row because each printed result is a separate row total.

new int[2][3] also creates two non-null rows with three zero-initialized int elements each. By contrast, new int[2][] creates two row slots whose values are initially null; it does not create their inner arrays. Establish the row before reading its length or its elements.

public class Main {
    public static void main(String[] args) {
        int[][] minutes = {{20, 30, 10}, {15, 25, 35}};
        System.out.println("Rows: " + minutes.length);
        System.out.println("Second row, third value: " + minutes[1][2]);
        for (int row = 0; row < minutes.length; row++) {
            int total = 0;
            for (int column = 0; column < minutes[row].length; column++) {
                total += minutes[row][column];
            }
            System.out.println("Row " + (row + 1) + " total: " + total);
        }
    }
}

Select Run code to compile and execute this program.

Rows: 2
Second row, third value: 35
Row 1 total: 60
Row 2 total: 75

Rows may have different lengths, be empty, or be missing

Java does not require every row to have the same length. The sessions example has a two-entry row, an empty row, a null row, and a one-entry row. This is often called a ragged or jagged array. Each existing row has its own independent length.

Check whether a row is null before accessing it. For an existing row, traverse that row's values or use its own length as the inner loop boundary. Reusing sessions[0].length for every row can fail on shorter rows and can ignore extra entries on longer rows.

The output distinguishes an empty row with entries=0 from a missing row. An empty outer array has no rows at all, so the outer loop runs zero times. Do not use row zero to determine a universal width unless your own data contract has already established that a nonempty rectangular grid exists.

public class Main {
    public static void main(String[] args) {
        int[][] sessions = {{20, 30}, {}, null, {15}};
        for (int row = 0; row < sessions.length; row++) {
            if (sessions[row] == null) {
                System.out.println("Row " + (row + 1) + ": missing");
                continue;
            }
            int total = 0;
            for (int minutes : sessions[row]) {
                total += minutes;
            }
            System.out.println("Row " + (row + 1) + ": entries=" + sessions[row].length + ", total=" + total);
        }
    }
}

Select Run code to compile and execute this program.

Row 1: entries=2, total=50
Row 2: entries=0, total=0
Row 3: missing
Row 4: entries=1, total=15

Copying the outer array does not copy its rows

Arrays.copyOf on int[][] creates another outer array, but copies the row references into it. The two outer arrays are different objects, while corresponding existing rows are initially shared. This is a shallow copy, not a full independent snapshot of all the nested integer storage.

Changing outerCopy[0][0] edits a shared row, so original also shows 99. Assigning a new array to outerCopy[1] instead replaces only that outer array's second row reference. original still refers to its old second row containing 30. Distinguish editing an element of a shared row from replacing a row reference.

For independent primitive rows, create a new outer array and copy each non-null int row separately. Preserve null rows deliberately if missing data matters. Do not assume Arrays.deepToString or deepEquals performs that copy: they format and compare, not duplicate storage. More deeply nested or object-containing structures require their own copying policy.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[][] original = {{10, 20}, {30}};
        int[][] outerCopy = Arrays.copyOf(original, original.length);
        outerCopy[0][0] = 99;
        outerCopy[1] = new int[] {77};
        System.out.println("Original: " + Arrays.deepToString(original));
        System.out.println("Outer copy: " + Arrays.deepToString(outerCopy));
        System.out.println("Same outer array: " + (original == outerCopy));
        System.out.println("Same first row: " + (original[0] == outerCopy[0]));
    }
}

Select Run code to compile and execute this program.

Original: [[99, 20], [30]]
Outer copy: [[99, 20], [77]]
Same outer array: false
Same first row: true

ArrayIndexOutOfBoundsException

Check the exact index and the selected array's length. A length of n permits 0 through n - 1. Guard first/last reads for empty arrays, and use each existing row's own length in nested traversal.

NullPointerException despite a non-null outer array

A row or reference element may still be null. new int[2][] creates an outer array with missing rows. Check the reference you are about to use, not just the outer container.

The local array variable might not have been initialized

Declaring int[] scores creates a variable, not an array. Assign an array before reading it. Element defaults apply after array creation and do not initialize every local reference automatically.

Editing a copy unexpectedly changes the original

Assignment aliases the same object, and copying an int[][] outer array still shares row objects. Choose a copy depth that matches the intended independence, and distinguish element mutation from replacing a reference.

The average is truncated or weights rows incorrectly

Cast before division to preserve fractions. Divide the grand total by the number of valid elements; do not average row means when their counts differ. Check the empty case before computing a mean.

The maximum is zero although every reading is negative

Zero was likely used as a false starting observation. After a nonempty guard, seed from an actual element. When validation can reject elements, seed from the first accepted value and handle the no-valid-values case separately.

References and related learning

The scenarios, explanations, examples, and exercises are original SovranCode material. Official references support the Java 21 language and library rules.

• Java 21 specification: arrays
• Java 21 Arrays API: copying, formatting, and comparison

Review traversal and skip rules · Review references and primitive values · Review calculations and formatting · Java course roadmap.

Last updated: 21 October 2026