How Arrays Work

References are opaque values

import java.util.Arrays;

public class ReferenceDemo {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] b = a;
        int[] c = Arrays.copyOf(a, a.length);

        b[0] = 99;
        System.out.println(a[0]);
        System.out.println(a == b);
        System.out.println(a == c);
    }
}

Output:

99
true
false

a and b hold equal reference values, so they designate one array. c designates a separate array with copied primitive elements.

The language permits a small set of reference operations. You can assign a reference, pass it, return it, compare it with ==, follow it to reach the object, or store null. You cannot convert it into a usable address or add an offset to it.

The stack and heap diagram is a teaching model

A normal HotSpot run manages arrays as garbage-collected objects. Method calls also have frames that hold execution state. It is useful to draw local variables in a stack frame and arrays in a heap region.

The Java language does not require every local value to occupy a stack slot. A JIT compiler can keep a value in a register, inline a method, or remove an allocation when the change cannot be observed. A garbage collector can move an array and update the references that reach it.

The stable fact is not an address. It is identity: references that designated the same array before a collection still designate the same array afterward.

Bounds are checked

For an array of length n, a valid index satisfies this invariant:

0 <= index && index < n

public class BoundsDemo {
    public static void main(String[] args) {
        int[] values = new int[3];
        System.out.println(values[2]);
        System.out.println(values[3]);
    }
}

The first line prints 0. The second throws ArrayIndexOutOfBoundsException because index 3 is outside the half-open range [0, 3).

The JVM must preserve that behaviour. A JIT may remove repeated checks only when it can prove the result would be unchanged.

Why fixed length matters

An array object never changes its length. Growth means creating another array and copying elements.

import java.util.Arrays;

public class GrowthDemo {
    public static void main(String[] args) {
        int[] oldValues = {2, 4, 6};
        int[] grown = Arrays.copyOf(oldValues, 6);
        grown[3] = 8;
        System.out.println(Arrays.toString(oldValues));
        System.out.println(Arrays.toString(grown));
    }
}

Output:

[2, 4, 6]
[2, 4, 6, 8, 0, 0]

ArrayList uses the same broad strategy. It keeps an internal array. When capacity is exhausted, it allocates a larger backing array and copies the existing references. The exact growth factor is an implementation detail, not an API promise.

Locality is common, not an address contract

Mainstream JVMs usually lay primitive array elements in a compact region. Sequential traversal can then benefit from processor caches and hardware prefetching.

That observation supports a performance hypothesis. It does not prove a fixed address, and it does not make every array loop faster than every alternative. Element type, access pattern, JIT compilation, cache state and workload size all matter. Measure the real workload with a suitable benchmark before making a performance claim.

Arrays of arrays can be jagged

int[][] means an array whose elements are references to int[] arrays. Rows can have different lengths, and a row can be null.

public class JaggedDemo {
    public static void main(String[] args) {
        int[][] triangle = {
            {1},
            {2, 3},
            {4, 5, 6}
        };

        for (int row = 0; row < triangle.length; row++) {
            for (int col = 0; col < triangle[row].length; col++) {
                System.out.print(triangle[row][col] + " ");
            }
            System.out.println();
        }
    }
}

Output:

1
2 3
4 5 6

Each inner loop uses triangle[row].length. A single column count is not valid for every jagged row.