arrays

the picture

a row of numbered lockers, all the same size, bolted together. you get to pick how many when you build it, and that number is final. locker numbers start at 0, so a row of 5 goes from 0 to 4.

int[] scores = {90, 72, 85};
String[] names = {"ada", "linus"};

making and using one

void main() {
    int[] a = {3, 1, 4, 1, 5};
    IO.println(a.length + " " + a[0] + " " + a[a.length - 1]);
    IO.println(Arrays.toString(new int[3]) + " " + Arrays.toString(new String[2]) + " " + Arrays.toString(new boolean[2]));
}

5 3 5
[0, 0, 0] [null, null] [false, false]

• {3, 1, 4} builds and fills one in one go. new int[5] makes an empty one of length 5.
• an empty array isn't empty, it's zeroed: 0 for numbers, false for booleans, null for references. (fields get the same defaults; local variables don't.)
• a.length is a field, no parentheses (unlike String.length(), a classic mixup).
• the last element is a[a.length - 1]. a[a.length] is one past the end.

java checks every index, every time. read past the end and you get an exception, never somebody else's memory (that's a whole class of C security bugs that can't happen here):

void main() {
    int[] a = new int[5];
    IO.println("reading a[5]...");
    IO.println(a[5]);
}

reading a[5]...
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5

printing and comparing

void main() {
    int[] a = {3, 1, 4, 1, 5};
    int[] b = Arrays.copyOf(a, 7);
    Arrays.sort(a);
    IO.println(Arrays.toString(a) + " " + Arrays.toString(b));
    int[] d = {1, 2, 3};
    int[] e = {1, 2, 3};
    IO.println((d == e) + " " + d.equals(e) + " " + Arrays.equals(d, e));
}

[1, 1, 3, 4, 5] [3, 1, 4, 1, 5, 0, 0]
false false true

two traps in there. println(a) on an array prints something like [I@5a4041cc (the type code for "int array", an @, and a hash), never the contents: use Arrays.toString. and both == and equals on arrays ask "same object?", so two arrays with identical contents aren't "equal". use Arrays.equals.

int[] a = {1, 2, 3};
for (int x : a) {
    x *= 2;
}
IO.println(Arrays.toString(a));

2d arrays are arrays of arrays

java has no real grid type. int[][] means "an array whose elements are int[]s". the outer array holds references, and each row is a separate array object:

int[][] grid = new int[3][4];
grid[1][2] = 9;

since each row is its own array, the rows don't have to be the same length. leave the second size out (new int[3][]) and you get the outer array only, rows to be filled in later:

·

Arrays.deepToString(grid) prints nested arrays ([[0, 0, 0, 0], [0, 0, 9, 0], [0, 0, 0, 0]]), since plain toString would print the rows' [I@... addresses.

Object[] o = new String[1];
o[0] = 42;