Arrays, one dimension

You can already store one number in a variable, and you can repeat work with a loop. But what happens when you have not one number to keep, but fifty? Naming fifty variables by hand is the problem this lesson solves. An array is a single name that holds many values in a row.

Fifty variables is fifty problems#

Picture a class of five students and you want to store each test score. With the tools you have so far, you reach for one variable per score.

It runs, and it is fine for five. Now the class grows to fifty. You would type fifty lines, each with a number stuck on the end of the name. Worse, suppose you wanted to print every score. You cannot loop, because a loop counter is just an int, and there is no way to say “the variable whose name ends in this number”. The names score0 through score4 look like a sequence to you, but to Java they are five unrelated variables that happen to share a prefix.

Key idea

Loose numbered variables do not scale. You cannot count over them with a loop, and the count of them is frozen into your source code. We need one name that holds many values and lets a number pick which one.

Two ways to build an array#

An array is a fixed-length row of slots, all of the same type, sitting under a single name. There are two common ways to make one.

One: list the values you already have

When you know the values up front, write them in curly braces. The type before the name has square brackets, int[], which reads as “array of int”. Java counts the values for you, so this array has exactly three slots.

Two: ask for empty slots with new int[n]

When you do not yet have the values, but you know how many you need, ask for that many empty slots with new int[n]. Here new int[5] hands you five slots. They are not random junk: Java fills a fresh number array with zeros. You then fill them in later.

Step through that and watch the array appear with five zeros, then watch slots 0 and 2 change while slot 1 stays at its default of zero. We never touched slot 1, so its starting value of 0 is exactly what prints.

Indexing: counting starts at zero#

Each slot has a position, called its index. You reach a slot by writing the array name, then the index in square brackets: scores[0] is the first slot. The single most important fact about arrays, and the one that trips up every beginner once, is that counting starts at zero, not one.

So an array of three values has indices 0, 1, and 2. The first is at 0, and the last is at 2, which is one less than the count of three. Read it as an offset: scores[0]means “zero steps from the start”, which is the start itself.

How many slots? Use .length

Every array carries its own size, which you read with .length. Note carefully: it is a plain field, scores.length, with no parentheses. This is a real difference from text. A String uses name.length() with parentheses, because there it is a method call. An array uses scores.length with none. Mixing them up is one of the most common early typos.

Walking an array with a for loop#

Here is where arrays and loops click together. A for loop can count from 0 up to length - 1, and at each step you use the counter as the index. One small loop now handles an array of three or three thousand without a single extra line. Run this and watch the index pointer move along the row, lighting up one cell at a time.

Read the loop condition slowly, because it is the heart of the whole pattern. We start i at 0, the first index. We keep going while i < scores.length, that is, while i is still 0, 1, or 2. The instant i reaches 3, the condition 3 < 3 is false and the loop stops, one step before trouble. Using < with length is the safe pattern. It visits every slot and never the phantom one past the end.

Key idea

The standard array walk is for (int i = 0; i < a.length; i = i + 1). Start at zero, stop strictly below the length. Memorize the shape; you will write it thousands of times.

Most Java code writes the update as i++, the shorthand from operators and casting, so you will often see the same walk written for (int i = 0; i < a.length; i++). It does exactly the same thing.

Printing a whole array#

You might expect System.out.println(scores) to show the values. It does not. It prints something like [I@1b6d3586: [Iis Java's code for “array of int”, and the part after the @is a number that identifies the array and can change from one run to the next. To see the values, walk the array as above, or let Java's library do the formatting:

Arrays is a class in java.util full of ready-made helpers for arrays, so it needs an import, as Scanner did. Arrays.toString(scores) builds the text [10, 20, 30]: the values in square brackets, separated by commas. It works for every kind of array, which is why the prices print as [2.5, 4.0] and the two empty String slots as [null, null].

A real task: find the largest value

Printing is nice, but the point of holding many values together is to compute over them. Here is the classic move: scan the array and remember the biggest number you have seen. We start by assuming the first slot is the winner, then we check the rest. Anyone bigger takes the crown.

Two details earn their keep. First, max starts as temps[0], not as 0. If you started at 0 and every value were negative, your answer would wrongly be 0, a number not even in the array. Seeding from the first real value avoids that trap. Second, the loop starts at i = 1, not 0, because slot 0 is already the current champion, so there is nothing to gain by comparing it with itself. Stepping through: max begins at 62, rises to 71, holds through 55, rises to 80, and holds through 68. The final answer is 80.

The for-each loop: when you do not need the index#

Often you want to visit every element but you do not actually care about its index, only its value. Java has a shorter loop for exactly this, the for-eachloop. You read it as “for each value in the array, do this”.

The shape is for (int age : ages). On each pass, age holds the next value from the array, in order, with no index variable to manage at all. Compare it with the counting loop: the for-each is cleaner when you only need the values, while the counting for is what you reach for when you need the position too (for example, to write into a slot, or to compare neighbours).

It prints [5, 10, 15]: the array has not changed. On each pass, p is a copy of the value in the current slot. Doubling the copy changes p and nothing else, and the next pass overwrites p with the next value. A for-each loop also hides the index, so it cannot look at two positions at once either. To change the slots themselves, use the counting loop and write through the index: prices[i] = prices[i] * 2;.

Summing and averaging an array#

The other everyday task is reducing a whole array to a single number, like a total or an average. The pattern is the same running-total idea from loops: keep an accumulator outside the loop and add each element into it.

The sum builds up to 28. The average line has one subtlety worth pausing on: we cast sum to double before dividing, so we get a real decimal average rather than an integer-division result. Without the (double), 28 / 5 would be the whole number 5, quietly dropping the fraction. This is the integer-division trap from operators and casting showing up in real code.

1public class Main {
2    public static void main(String[] args) {
3        int[] scores = {72, 45, 90, 61, 84, 53};
4        int sum = 0;
5 
6        // TODO: add up the scores, then work out the average as a double
7        double average = 0;
8        System.out.println("Average: " + average);
9 
10        // TODO: print every score that is above the average, one per line
11    }
12}

Putting an array in order: bubble sort#

Sorting is the classic array workout, and the gentlest method to understand is bubble sort. The idea: walk the array comparing each pair of neighbours, and whenever the left one is bigger, swap them. After one full pass the largest value has “bubbled” to the end. Repeat enough passes and the whole array is sorted.

Two ideas are doing the work. The swap uses a temp variable to hold one value while the two slots trade places, because if you just wrote arr[j] = arr[j+1] first you would overwrite and lose one of them. And the inner loop stops a little earlier each pass (arr.length - 1 - i), because after each pass one more large value is already parked at the end and does not need checking again. Step through it and watch the largest values drift right until the row reads 1 2 3 6 7.

Copying an array: two names, one row#

Bubble sort rearranged arr itself, so the original order is gone. Often you want to keep the original and work on a copy. Here is the obvious first try, with an array of scores and the line int[] backup = scores;. Decide what this program prints before you run it.

It prints scores[0] is 0. The line int[] backup = scores; did not copy any values. An array variable holds a reference: directions to where the row of slots lives in memory. The assignment copied the directions, so both names now lead to the same row, and a change made through either name shows up through the other. Two names for one array like this is called aliasing.

To get a real copy, make a new array of the same length and copy the values across, slot by slot. Step through this version and watch the memory view: this time there are two separate rows, and changing one leaves the other alone.

The output is [70, 85, 90] for scores and [0, 85, 90] for backup. The library can do the copying for you: int[] backup = Arrays.copyOf(scores, scores.length); makes the new array and fills it in one line. The second argument is how long the copy should be.

Key idea

b = a gives the same array a second name. To get a separate array, copy the values into a new one, with a loop or with Arrays.copyOf.

1import java.util.Arrays;
2 
3public class Main {
4    public static void main(String[] args) {
5        int[] original = {3, 1, 4, 1, 5};
6        int[] reversed = new int[original.length];
7 
8        // TODO: fill reversed with the values of original, back to front
9 
10        System.out.println(Arrays.toString(original));
11        System.out.println(Arrays.toString(reversed));
12    }
13}

Stepping off the end#

What if you do ask for a slot that does not exist? Some languages quietly hand back whatever happens to sit in memory past the end. Java never does. It stops the program with a clear, named error: an ArrayIndexOutOfBoundsException. Run this loop to trigger one on purpose. It is wrong by exactly one: it uses <= where it should use <.

Trace it by hand. It prints day 0, day 1, and day 2 happily, then i becomes 3. Because the condition is i <= days.length, that is 3 <= 3, which is true, so the loop runs one more time and reaches for days[3]. But the valid indices are only 0, 1, 2. Index 3 is off the end, and Java stops with ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3. The fix is the single character we kept stressing: use <, not <=.

The array problem set#

Here is the real practice: ten array problems, plus a bonus, each solved using only arrays and for loops, nothing fancier. Read each one, predict the output, then press Run and step through to check yourself. These are the exact moves you will reach for again and again.

1. Circular neighbor sum

Build a new array where each element is the sum of its left and right neighbors. The array wraps around: the first element's left neighbor is the last, and the last element's right neighbor is the first.

2. Mirror difference array

Each element becomes the absolute difference between it and its mirrored counterpart from the other end of the array.

3. Leader elements

An element is a leader if it is greater than every element to its right. Print all leaders.

4. Array wave formation

Rearrange the array into a wave, where each adjacent pair is swapped so the values rise and fall.

5. Longest increasing streak

Find the length of the longest run of consecutive increasing values.

6. Frequency count, without a HashMap

Print how many times each unique value occurs, using only arrays and loops. Skip a value if you have already counted it earlier.

7. Alternate positive and negative

Lay out positives at even indices and negatives at odd indices, so the signs alternate.

8. First repeating element

Find the first value that appears more than once, then stop. The classic double for loop. The return; on its own line ends main straight away, and with it the program.

9. Array mountain check

Decide whether the array strictly rises, then strictly falls, with the peak at neither end. Like problem 8, it uses return; to end main as soon as the answer is known.

10. Balance point

Find an index where the sum of everything on the left equals the sum of everything on the right.

Bonus: array cipher

Each number is a letter: 1 is A, 2 is B, up to 26 is Z. Turn the array into a word. This leans on the char-and-number trick from operators and casting.

Further reading#

• Creating arrays in your programs, on dev.java, the official Java learning site
• java.util.Arrays in the Java SE 25 API documentation: toString, copyOf, equals, sort and the other helpers
• Arrays in the Java Language Specification, chapter 10, the exact rules for creating and indexing arrays