Arrays: creation, indexing and iteration

Six students’ marks in six separate variables need six names, and every total, average or search has to mention all six. An array keeps a fixed number of values of one type together in one object, numbered from 0: int[] marks = new int[5]; creates five int elements that all start at 0, and int[] marks = {71, 64, 88, 92, 57}; creates five with those values. The JVM checks every index you use, and an array variable holds a reference to the array, so int[] b = a; gives one array a second name instead of copying it.

You will create arrays and loop over them without stepping past the end, step through what an assignment, a copy and a method call do to one array, and meet the two errors arrays are known for. Every program is a compact source filecompact source file: A .java file whose fields and methods are written with no class declaration around them, such as a file that holds only a main method. JEP 512 made it a permanent part of Java in JDK 25. More in “Your first program: a compact source file”, run with java Name.java on JDK 25.

new int[5] fixes the length and fills in default values

Defaults.java creates arrays in three ways, prints what each new array holds before anything is stored in it, and then asks for a negative length:

// Three ways to create an array, what a new array holds before anything is stored in it,
// and what happens when the length is negative.
void main() {
    int[] marks = new int[5];               // five ints
    double[] prices = new double[3];
    boolean[] present = new boolean[4];
    char[] initials = new char[2];
    String[] names = new String[3];         // three references, no String objects yet

    IO.println("marks    " + Arrays.toString(marks) + ", length " + marks.length);
    IO.println("prices   " + Arrays.toString(prices));
    IO.println("present  " + Arrays.toString(present));
    IO.println("initials " + (int) initials[0] + " and " + (int) initials[1]
            + " (character codes)");
    IO.println("names    " + Arrays.toString(names));

    int[] days = {31, 28, 31, 30};          // an initialiser: the compiler counts the values
    int[] none = {};                        // an empty array, which is not the same as null
    String[] cities;
    cities = new String[] {"Pune", "Kochi"};  // outside a declaration, name the type
    IO.println("days " + days.length + ", none " + none.length + ", cities " + cities.length);

    int n = -1;
    try {
        int[] wrong = new int[n];
    } catch (NegativeArraySizeException e) {
        IO.println("new int[-1]: " + e);
    }
}

marks    [0, 0, 0, 0, 0], length 5
prices   [0.0, 0.0, 0.0]
present  [false, false, false, false]
initials 0 and 0 (character codes)
names    [null, null, null]
days 4, none 0, cities 2
new int[-1]: java.lang.NegativeArraySizeException: -1

• new int[5] fixes the length and fills in default values. The Java Language Specification gives every array element a default valuedefault value: The value every element of a new array starts with, before anything is stored in it: 0 for the integer types, 0.0 for float and double, false for boolean, the character with code 0 for char, and null for every reference type. when the array is created, the one the table below lists for its type. A new String[3] therefore holds three nulls, not three empty strings: no String objects exist until you store some.
• An initialiser lists the values, and the compiler counts them: days has 4 elements. The short form {31, 28, 31, 30} works only in a declaration. Anywhere else, for example when you assign the variable later or pass an array straight to a method, write the type as well: new String[] {"Pune", "Kochi"}.
• length is a field, not a method, so it has no parentheses: marks.length, but name.length() for a String. It is final. Once an array exists its length never changes, so to make room for more elements you create a longer array and copy the old ones into it, as Arrays.copyOf does further down, or use an ArrayList, which does that for you and has a lesson in the collections module.
• An empty array is not null. none has length 0, and a loop over it simply runs zero times. A variable that holds null refers to no array at all, and reading its length throws NullPointerException.
• A negative length is a run-time error. The compiler cannot know what n will hold, so new int[n] with n = -1 compiles and then throws NegativeArraySizeException. A length of 0 is fine.

What a new element holds, by its type, with the lines of the run that show it:

Write the brackets after the type, int[] marks. Java also accepts the C style, int marks[], but the specification recommends against mixing the two styles in one declaration, and int[] marks keeps the whole type in one place.

The JVM checks every index you use

marks[0] is the first element and marks[marks.length - 1] the last; marks[2] = 90; replaces the third. The index can be any expression of type int (a long index does not compile), and the JVM checks it every time the access runs. The usual way to trip that check is a loop condition written with <=:

// The classic off-by-one mistake: i <= marks.length visits one index too many.
void main() {
    int[] marks = {71, 64, 88, 92, 57};
    int total = 0;
    for (int i = 0; i <= marks.length; i++) {    // the last valid index is marks.length - 1
        total += marks[i];
        IO.println("i = " + i + ": total " + total);
    }
    IO.println("total: " + total);               // never reached
}

i = 0: total 71
i = 1: total 135
i = 2: total 223
i = 3: total 315
i = 4: total 372

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at OffByOne.main(OffByOne.java:6)

The loop printed five running totals and then stopped. Step through it to see why a sixth pass started at all, and where the check caught it:

The message says what happened, Index 5 out of bounds for length 5, and the line under it, the top of the stack tracestack trace: What an uncaught exception prints: its class and message, then the calls that were open when it was thrown, the most recent first, each with its file and line, and any Caused by sections. More in “IDEs, compiler errors and your first debug”, says where: line 6 of OffByOne.java. A five-element array has the indexes 0 to 4, and i <= marks.length lets i reach 5. The program stopped at that access, so the line after the loop never ran, and nothing was read from outside the array. An index below 0 fails in the same way.

for-each gives you the values, and an indexed loop the positions too

Both loops from the lesson on loops work on arrays. The for-each loopenhanced for loop: for (T x : items), also called for-each: it gives x each element of an array or an Iterable in turn, with no index, so it cannot step past the end, and x holds a copy of each element. More in “Loops: while, do-while, for and for-each”, for (int m : marks), gives you each value in turn, with no index to get wrong. The indexed loop, for (int i = 0; i < marks.length; i++), gives you the position as well. With arrays, the choice mostly comes down to whether you need that position:

// Statistics over one test's marks (out of 100). A for-each loop where only the values matter,
// an indexed loop where the position matters too.
void main() {
    String[] names = {"Asha", "Ravi", "Meera", "Kabir", "Divya", "Arjun"};
    int[] marks = {71, 64, 88, 92, 57, 88};      // marks[i] belongs to names[i]

    int total = 0;
    for (int m : marks) {                        // every value, no index to get wrong
        total += m;
    }
    double average = (double) total / marks.length;

    int best = 0;                                // the INDEX of the highest mark so far
    for (int i = 1; i < marks.length; i++) {
        if (marks[i] > marks[best]) {
            best = i;
        }
    }

    int above = 0;
    for (int m : marks) {
        if (m > average) above++;
    }

    IO.println("students: " + marks.length + ", total: " + total);
    IO.println("average: " + String.format("%.2f", average));
    IO.println("highest: " + marks[best] + " by " + names[best] + " (index " + best + ")");
    IO.println("above the average: " + above);
}

students: 6, total: 460
average: 76.67
highest: 92 by Kabir (index 3)
above the average: 3

The total and the count above the average need only the values, so for-each is the clearer loop for them. Finding who scored highest needs a position: best holds the index of the best mark so far, and names[best] uses the same index in the second array. Two arrays kept in step like this are called parallel arraysparallel arrays: Two or more arrays kept in step by index, such as names[i] and marks[i] for one student. Sorting or changing one of them without the others breaks the link, which is why one array of records is usually safer.. They work, but the next lesson shows how sorting one of them separates names from marks, and the cure, an array of records. Two details matter in the arithmetic: (double) total / marks.length makes the division a decimal one (without the cast, 460 / 6 is 76), and starting with best = 0 assumes the array has at least one element. An empty array would make marks[best] throw, so a method that might receive one checks marks.length first.

The specification defines the for-each loop over an array as an indexed loop that assigns a[i] to the loop variable at the start of every pass. So the variable is a copy of the element, and assigning to it never changes the array, as the lesson on loops showed with numbers. In an array of objects, each element is a reference, and the copy refers to the same object:

// The variable of a for-each loop is a copy of each element. In an array of objects, each
// element is a reference, so the loop can change the objects themselves, but it cannot put
// another object into the array.
void main() {
    StringBuilder[] labels = {
        new StringBuilder("A1"), new StringBuilder("A2"), new StringBuilder("A3"),
    };
    for (StringBuilder label : labels) {
        label.append('*');                        // changes the object this element refers to
    }
    IO.println("after append: " + Arrays.toString(labels));
    for (StringBuilder label : labels) {
        label = new StringBuilder("??");          // redirects only the loop's copy
    }
    IO.println("after assign: " + Arrays.toString(labels));
}

after append: [A1*, A2*, A3*]
after assign: [A1*, A2*, A3*]

Step through both loops, one reference at a time:

label.append('*') changed the object that the element and the copy both refer to, which the array then shows. Assigning label = new StringBuilder("??") only redirected the copy, and the array kept its three builders. To put a different object into an element, you need its index: labels[i] = ….

println shows an array’s class and hash code, and Arrays.toString its elements

Passing an array to IO.println or System.out.println does not print its elements:

// What println shows for an array, and what Arrays.toString shows.
void main() {
    int[] marks = {71, 64, 88};
    String[] cities = {"Pune", "Kochi"};
    IO.println(marks);                           // its type and a hash code, not the elements
    IO.println(cities);
    IO.println(Arrays.toString(marks));          // the elements
    IO.println(Arrays.toString(cities));
    int[] missing = null;
    IO.println(Arrays.toString(missing));        // "null", without an exception
}

[I@120d6fe6
[Ljava.lang.String;@4ba2ca36
[71, 64, 88]
[Pune, Kochi]
null

An array inherits toString from Object, which returns the name of the object’s class, an @ and the object’s hash code in hexadecimal. The five lines of the run, one by one:

The hash code identifies the object, not its contents, and the Object documentation warns that this text may change from one run to the next. Arrays.toString is what you want: the elements in square brackets, separated by commas. It also accepts null and returns the text null instead of throwing.

An array variable holds a reference, and an assignment shares it

An array is an object. The JVM allocates it on the heapThe memory where the JVM keeps the objects a program creates, shared by the whole program. A variable never holds an object itself, only a reference to one there., and an array variable holds a reference to it, just as a String variable holds a reference to a string. An assignment between two array variables duplicates that reference and nothing else, which leaves you with two names for one set of elements:

// A "backup" that is not a backup: assigning an array variable copies the reference,
// not the elements.
void main() {
    int[] marks = {71, 64, 88, 92, 57};
    int[] backup = marks;                        // one array with two names

    marks[4] = 75;                               // a re-evaluated paper
    IO.println("marks  " + Arrays.toString(marks));
    IO.println("backup " + Arrays.toString(backup) + "  <- changed as well");
    IO.println("marks == backup: " + (marks == backup));

    // Three ways to copy the elements into a new array.
    int[] cloned = marks.clone();
    int[] copied = Arrays.copyOf(marks, marks.length);
    int[] longer = Arrays.copyOf(marks, 7);      // extra elements are 0
    int[] target = new int[5];
    System.arraycopy(marks, 0, target, 0, marks.length);

    marks[0] = 0;                                // change the original again
    IO.println("marks  " + Arrays.toString(marks));
    IO.println("cloned " + Arrays.toString(cloned) + ", cloned == marks: " + (cloned == marks));
    IO.println("copied " + Arrays.toString(copied));
    IO.println("longer " + Arrays.toString(longer));
    IO.println("target " + Arrays.toString(target));
}

marks  [71, 64, 88, 92, 75]
backup [71, 64, 88, 92, 75]  <- changed as well
marks == backup: true
marks  [0, 64, 88, 92, 75]
cloned [71, 64, 88, 92, 75], cloned == marks: false
copied [71, 64, 88, 92, 75]
longer [71, 64, 88, 92, 75, 0, 0]
target [71, 64, 88, 92, 75]

backup was meant to keep the old marks, yet it shows 75 straight away: int[] backup = marks; made no copy, and marks == backup is true because == on arrays compares references. It asks whether two variables lead to the same object, never whether two arrays hold the same values. Two names for one object are aliasesalias: A second name for the same object: after int[] b = a; both variables refer to one array, so a change made through either is seen through the other, and a == b is true.. Step through the program and watch the arrows:

Each of the three real copies is a new array, so each keeps its values when marks changes again:

• marks.clone() returns a new array of the same type and length with the same elements. Every array has this public clone method, and for an int[] it returns an int[], so no cast is needed.
• Arrays.copyOf(marks, n) returns a new array of length n. A shorter length cuts elements off; a longer one pads with the default value, here 0. It is the usual way to grow an array.
• System.arraycopy(src, srcPos, dest, destPos, length) copies into an array you already have, starting at any position on either side. When the two ranges overlap inside one array, it behaves as if it had copied through a temporary array, so the result is still right.

These copies are complete only for arrays of primitiveprimitive type: One of the eight value types built into Java: byte, short, int, long, float, double, char and boolean. A variable of a primitive type holds the value itself and has no methods. More in “Variables and the eight primitive types” values. A copy of a String[], or of any array of objects, holds the same references, so both arrays point to the same objects: a shallow copyshallow copy: A copy that copies the references an array or object holds but not the objects they refer to, so the copy and the original share those objects. clone() on an int[][] copies only the outer array of row references. More in “2D and jagged arrays for grids and matrices”, and the lesson on two-dimensional arrays shows where it bites. To compare two arrays by their contents, use Arrays.equals(a, b), which the next lesson covers with the rest of the Arrays class.

A method gets the reference by value, so it can change your elements

A method parameter of an array type receives a copy of the caller’s reference, never a copy of the array. Java passes every argument this way, by valuepass-by-value: Passing a copy of each argument's value to the method's parameter, which is how Java passes every argument. For an object the value copied is a reference, so the method can change the object but never the caller's variable. More in “Methods, parameters, return and overloading”, and the value of an array variable is a reference:

// A method receives a copy of the reference. It can change the caller's elements,
// but pointing its own parameter at another array changes nothing for the caller.
void addGrace(int[] marks) {
    for (int i = 0; i < marks.length; i++) {
        marks[i] += 2;                           // writes into the caller's array
    }
}

void replace(int[] marks) {
    marks = new int[] {100, 100, 100};           // only the parameter points elsewhere now
}

int[] withGrace(int[] marks) {
    int[] result = marks.clone();                // leave the caller's array as it is
    for (int i = 0; i < result.length; i++) {
        result[i] += 2;
    }
    return result;
}

void main() {
    int[] marks = {71, 64, 88};
    addGrace(marks);
    IO.println("after addGrace: " + Arrays.toString(marks));
    replace(marks);
    IO.println("after replace:  " + Arrays.toString(marks));
    int[] graced = withGrace(marks);
    IO.println("withGrace returned " + Arrays.toString(graced)
            + ", marks is still " + Arrays.toString(marks));
}

after addGrace: [73, 66, 90]
after replace:  [73, 66, 90]
withGrace returned [75, 68, 92], marks is still [73, 66, 90]

Step through the three calls and watch which arrows each method can move:

addGrace changed the caller’s marks, because it wrote through the shared reference. replace changed nothing for the caller: assigning a new array to marks inside the method only moved that method’s own copy of the reference. withGrace is the safe pattern for a method that must leave its argument alone: copy first, change the copy, return it. A method that changes an array it was given, without saying so, is one of the most common sources of bugs with arrays, so when a method does change its argument, make that clear in its name and its documentation.

A String[] is also an Object[], so a wrong store fails while the program runs

Arrays are covariantarray covariance: The rule that an array of a subtype is also an array of its supertype, so a String[] may be assigned to an Object[]. The JVM then checks every store into an array of references while the program runs and throws ArrayStoreException for a value of the wrong type.: because a String can be assigned to an Object, a String[] can be assigned to an Object[]. That suits methods that accept any array of objects, but it lets the compiler accept a store that cannot work:

// Arrays are covariant: a String[] may be used wherever an Object[] is expected,
// so the JVM checks every store into an array of references while the program runs.
void main() {
    String[] cities = {"Pune", "Kochi"};
    Object[] things = cities;                    // compiles: a String[] is an Object[]
    things[0] = "Jaipur";                        // a String: allowed
    IO.println(Arrays.toString(cities));
    try {
        things[1] = 42;                          // compiles, but the array holds Strings
    } catch (ArrayStoreException e) {
        IO.println("caught " + e);
    }
    IO.println(Arrays.toString(cities));
}

[Jaipur, Kochi]
caught java.lang.ArrayStoreException: java.lang.Integer
[Jaipur, Kochi]

Step through the two stores, first as the compiler sees them, then as the JVM does:

To the compiler, things is an Object[] and 42 is an Object, so things[1] = 42 compiles. The array object, though, was created as a String[] and keeps that type while the program runs, and the JVM checks every store into an array of references. The value is an Integer, not a String, so the store throws ArrayStoreException and the array keeps its old contents. Generic collections close this gap at compile time instead: a List<String> is not a List<Object>, so the same mistake with lists does not compile, which is one reason later modules prefer collections in the parameters of methods.

Practise: running totals and rotation

Complete the two methods at the top of RunningTotals.java; the rest of the file is a set of checks that call them. Both methods throw until you write them, so the first run lists eight failures and exits with status 1:

// Your turn. Write runningTotal and rotate, then run this file until every check passes:
//     java RunningTotals.java
//
// runningTotal(a) returns a new array whose element i is a[0] + a[1] + ... + a[i]:
//     {3, 1, 4} gives {3, 4, 8}.
// rotate(a, k) returns a new array in which every element moves k places to the right,
// and the ones that fall off the end come back at the front:
//     rotate({1, 2, 3, 4, 5}, 2) gives {4, 5, 1, 2, 3}.
// A negative k moves the elements to the left.
// Neither method may change a, and each one creates exactly one new array.

int[] runningTotal(int[] a) {
    throw new UnsupportedOperationException("not written yet");
}

int[] rotate(int[] a, int k) {
    throw new UnsupportedOperationException("not written yet");
}

// ---- The checks. You do not need to change anything below this line. ----

int checks = 0;
int failed = 0;

void checkTotal(int[] a, int[] want) {
    checks++;
    String call = "runningTotal(" + Arrays.toString(a) + ")";
    int[] before = a.clone();
    try {
        compare(call, a, before, runningTotal(a), want);
    } catch (RuntimeException e) {
        fail(call + " threw " + e);
    }
}

void checkRotate(int[] a, int k, int[] want) {
    checks++;
    String call = "rotate(" + Arrays.toString(a) + ", " + k + ")";
    int[] before = a.clone();
    try {
        compare(call, a, before, rotate(a, k), want);
    } catch (RuntimeException e) {
        fail(call + " threw " + e);
    }
}

void compare(String call, int[] a, int[] before, int[] got, int[] want) {
    if (!Arrays.equals(got, want)) {
        fail(call + " returned " + Arrays.toString(got)
                + ", expected " + Arrays.toString(want));
    } else if (got == a) {
        fail(call + " returned its argument, not a new array");
    } else if (!Arrays.equals(a, before)) {
        fail(call + " changed its argument to " + Arrays.toString(a));
    }
}

void fail(String message) {
    failed++;
    IO.println("FAIL " + message);
}

void main() {
    checkTotal(new int[] {3, 1, 4}, new int[] {3, 4, 8});
    checkTotal(new int[] {7}, new int[] {7});
    checkTotal(new int[] {}, new int[] {});
    checkRotate(new int[] {1, 2, 3, 4, 5}, 2, new int[] {4, 5, 1, 2, 3});
    checkRotate(new int[] {1, 2, 3, 4, 5}, 0, new int[] {1, 2, 3, 4, 5});
    checkRotate(new int[] {1, 2, 3, 4, 5}, 7, new int[] {4, 5, 1, 2, 3});
    checkRotate(new int[] {1, 2, 3, 4, 5}, -1, new int[] {2, 3, 4, 5, 1});
    checkRotate(new int[] {}, 3, new int[] {});
    IO.println(failed + " of " + checks + " checks failed");
    if (failed > 0) System.exit(1);
}

FAIL runningTotal([3, 1, 4]) threw java.lang.UnsupportedOperationException: not written yet
FAIL runningTotal([7]) threw java.lang.UnsupportedOperationException: not written yet
FAIL runningTotal([]) threw java.lang.UnsupportedOperationException: not written yet
FAIL rotate([1, 2, 3, 4, 5], 2) threw java.lang.UnsupportedOperationException: not written yet
FAIL rotate([1, 2, 3, 4, 5], 0) threw java.lang.UnsupportedOperationException: not written yet
FAIL rotate([1, 2, 3, 4, 5], 7) threw java.lang.UnsupportedOperationException: not written yet
FAIL rotate([1, 2, 3, 4, 5], -1) threw java.lang.UnsupportedOperationException: not written yet
FAIL rotate([], 3) threw java.lang.UnsupportedOperationException: not written yet
8 of 8 checks failed

You are done when java RunningTotals.java prints 0 of 8 checks failed. The checks also catch a method that returns its argument instead of a new array, or that changes its argument: the two reference mistakes of this lesson. One hint for rotate: element i moves to index (i + k) % n, but Java’s % keeps the sign of the number on its left, so -1 % 5 is -1, not 4. Math.floorMod(-1, 5) gives 4. An empty array needs a case of its own, because % 0 throws ArithmeticException.

Then try the practice below on the seven ideas of the lesson, from default values to the store check. It opens on the array rule you miss most, and every option spells out the array behaviour behind it:

Interview questions

Fresher · What does int[] b = a; do in Java, and how do you get an independent copy of an int array?

It copies the reference, not the array. After the assignment, a and b refer to the same array object, so b[0] = 9 is visible through a, and a == b is true. To get an independent copy, create a new array with the same elements: a.clone(), Arrays.copyOf(a, a.length), which can also make the copy longer or shorter, or System.arraycopy into an array you created yourself. For an array of primitives such as int[], each of these is a complete copy. For an array of objects, each copies only the references, so the copy and the original share the objects themselves. A good answer also says how to check the result: a == copy is false, while Arrays.equals(a, copy) is true.

Interviewers often follow this answer with copies of arrays of objects. Work out what each snippet does before you look at the reasons:

This lesson is also the starting point of two longer questions in the module bank: a helper that sorts the array it was given, and a library method that throws ArrayStoreException for one caller only.

Key takeaways

• An array has a fixed length, set by new int[n] or counted from an initialiser such as {71, 64, 88}, and every new element starts at its type’s default: 0, 0.0, false, the character with code 0, or null.
• Indexes run from 0 to length - 1, and the JVM checks every access: a loop with i <= a.length throws ArrayIndexOutOfBoundsException on its extra pass, and the message names the index and the length.
• for-each reads every value with no index to get wrong; its variable is a copy of each element, so it can change the objects an array refers to but never replace an element, which takes an indexed loop.
• Printing an array shows its class name and a hash code, such as [I@ and hexadecimal digits; Arrays.toString shows the elements.
• An array variable holds a reference: b = a shares one array, == compares references, clone(), Arrays.copyOf and System.arraycopy copy the elements, and a method can change the elements of an array it receives, so copy first when it must not.
• Because a String[] is also an Object[], storing a value of the wrong type compiles and then throws ArrayStoreException.