Java arrays and bounds

Working model

Allocate the array when its length is known. Indexing is O(1), but valid indices stop at length - 1. An array with length zero is valid and has no readable element.

Code

int[] dailyOrders = {12, 0, 8, 15};
int totalOrders = 0;
for (int orders : dailyOrders) {
    totalOrders += orders;
}
System.out.println(totalOrders);

The output is 35. Summation visits every element: O(n) time and O(1) extra space. A larger input may overflow an int total, so select the accumulator type from the expected range.

Cost and design choices

An array reference can be shared. Passing dailyOrders into a method does not create a separate array. Copy it when a caller must keep an unchanged snapshot.

Aliasing, covariance, and copying

Arrays.copyOf creates another array but only copies references for object elements. If an element is mutable, both arrays still reach that element. A two-dimensional Java array is an array of row references, so copying the outer array also shares the original rows.

A reference array can be assigned to a wider reference-array type. Its actual component type still controls writes, so storing an incompatible element throws ArrayStoreException. Generic lists use a different invariance rule that catches many such assignments at compilation.

Connected lessons

Continue with Java strings and content equality, Java Tutorial.

Common Mistakes

Do not assume every row of a two-dimensional array has the same length. Validate an index before accessing it. An array of object references initially contains null unless each element is assigned.

Distinguish membership copies from nested copies

An array has fixed membership length and mutable slots. Assigning it to another variable shares those slots. clone makes another outer array, but a nested array or mutable element can still be shared. Decide whether callers need independent rows or merely independent outer membership.

Java multidimensional arrays are arrays of arrays. Rows can have different lengths and can be null. A loop using the first row’s length for every row invents a rectangular-shape contract that the representation itself does not guarantee.

Bounds checks protect access at runtime but do not make an off-by-one algorithm correct. Test empty input, one element and the final position. A copied snapshot also adds allocation and O(n) element-reference work; it should appear in the method’s space cost rather than vanish behind the word copy.