Many values, one name

Say your class of 30 people just sat a test, and you want the average mark. You already know how to make a box in memory and put a number in it. So you'd need thirty boxes: mark1, mark2, mark3… That's thirty lines of typing. Then one enormous adding-up line at the end. Now imagine the whole school. Nine hundred people. You are not going to type nine hundred names. Nobody is. So programmers do something else instead, and it's the trick this whole chapter is about.

What you'll be able to do

• Keep many values — 5 or 5,000 — under one name, and reach any one of them instantly.
• Explain to someone else why the first slot is numbered 0, without shrugging.
• Read the crash message Java gives you when you reach past the end, and fix it.
• Walk every slot with a loop, and pick the right loop for the job.

Section 1One name, many numbered slots

Here's the thirty-boxes problem in miniature. Five test scores, done the painful way, then done properly. Both halves of this program print the same total.

// The silly way: one name per value.
int score1 = 8;
int score2 = 5;
int score3 = 9;
int score4 = 7;
int score5 = 6;
int total = score1 + score2 + score3 + score4 + score5;

// The sensible way: one name, five numbered slots.
int[] scores = {8, 5, 9, 7, 6};
int sum = 0;
for (int i = 0; i < scores.length; i++) {
    sum = sum + scores[i];
}

Line by line. The first five lines make five separate boxes in memory, each with its own label, exactly as in chapter 0.2. Line six reaches into all five and adds them up. Fine for five. Hopeless for nine hundred.

Then the interesting half. int[] scores says "this name won't hold one whole number — it will hold a row of whole numbers". That pair of square brackets is the whole difference. {8, 5, 9, 7, 6} fills the row in, left to right. Next line makes a counter starting at nothing. Then the loop from 0.3 walks the row, adding each value onto sum. It doesn't matter whether the row holds 5 values or 5,000 — that loop is the same length either way.

That row of values has a name: an array. An array is one name that owns a fixed number of slots, and every slot is numbered.

Making an array when you don't have the values yet

Sometimes you know how many slots you want but not what goes in them. Maybe the marks haven't been typed in yet. For that there's a second way to make an array:

int[] numbers = new int[3];
boolean[] flags = new boolean[3];
String[] names = new String[3];
double[] prices = new double[3];

System.out.println("numbers[0] = " + numbers[0]);
System.out.println("flags[0]   = " + flags[0]);
System.out.println("names[0]   = " + names[0]);
System.out.println("prices[0]  = " + prices[0]);

Each of the first four lines does the same job for a different kind of value. Read new int[3] out loud as "make me a new row with three int slots". new is Java's word for "build me one of these, right now, in memory". The number in brackets is how many slots, and it's locked in forever.

The four println lines then peek into slot 0 of each row. Nobody put anything in those slots. So what comes out?

numbers[0] = 0
flags[0]   = false
names[0]   = null
prices[0]  = 0.0

Section 2Counting starts at zero, and here's why

You've seen scores[0] a few times now and probably let it slide. Stop and look at it. This is where more beginners lose more hours than anywhere else in the language.

The first slot of an array is slot number 0. The second is 1. The third is 2. So an array with 5 slots has slots numbered 0, 1, 2, 3, 4. There is no slot 5. Read that again. An array of 5 has no slot 5.

That's not a random choice by Java's designers. It's the shape of the machine underneath. An array lives in memory as one unbroken run of boxes, all the same size, one after another. Java remembers where the run starts. To find slot i, it adds i box-widths to the start. Slot 0 needs no adding at all. Counting from 1 would mean subtracting 1 on every single access, forever, in every program on earth. So we count from 0.

So the last slot is always at index length - 1. Burn that phrase in. Here it is working:

String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri"};

System.out.println("length is " + days.length);
System.out.println("days[0] is " + days[0]);
System.out.println("days[1] is " + days[1]);
System.out.println("last slot number is " + (days.length - 1));
System.out.println("days[days.length - 1] is " + days[days.length - 1]);

Line one builds the five-slot array. The next three lines ask three easy questions: how many slots, what's in slot 0, what's in slot 1. Then the arithmetic out loud: 5 slots means 4 is the last index. The final line is the pattern worth stealing. Put that subtraction inside the brackets. Now you get the last item without knowing how long the array is.

length is 5
days[0] is Mon
days[1] is Tue
last slot number is 4
days[days.length - 1] is Fri

Why .length has no brackets

You have now typed days.length several times with no round brackets after it. That is worth one minute.

An array's size is a field — a fact stored on the thing itself. Think of a label stuck on the side of a box. You read a label. You don't run it.

Round brackets mean something specific in Java: "run this piece of work". That's what they meant on the methods you wrote in 0.4. No brackets means "read this stored fact". An array's size is decided the moment it is built and never moves, so there is nothing to work out. Java wrote the number down. You read it.

You have been writing String since 0.2, and text asks for its size a different way — with brackets. There is a real reason for that, and it belongs to chapter 0.6, where text gets opened up properly. For now, arrays: no brackets.

Now let's break something on purpose

Remember the promise from the stepper: reach past the end and Java stops the program. Let's do it from inside a method. Then we can read the trail it leaves behind — the same stack traces you met in 0.4.

public static void main(String[] args) {
    String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri"};
    System.out.println("About to read slot 5...");
    printSlot(days, 5);
    System.out.println("You will never see this line.");
}

static void printSlot(String[] items, int slot) {
    System.out.println(items[slot]);
}

Five slots, numbered 0 to 4. We print a warning. Then we hand the array and the number 5 to a little method called printSlot. Its only job is to print whatever slot it was told to look at. Back in main there's one more println that we're betting never runs.

About to read slot 5...
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at Crash.printSlot(Crash.java:11)
	at Crash.main(Crash.java:6)

Ten seconds that will save you an hour

Reading "it starts at zero" is not the same as believing it. Here are five slots. The page will ask for one by its index. You click the box you think it means. Get it wrong once and you'll never get it wrong again — which is the entire point.

Section 3Visiting every slot

Arrays are only useful if you can walk them. There are two ways, and choosing between them is easy once you know the question to ask.

String[] pets = {"cat", "dog", "rat"};

for (int i = 0; i < pets.length; i++) {
    System.out.println(i + ": " + pets[i]);
}

for (String pet : pets) {
    System.out.println(pet);
}

The first loop is the counting one from 0.3. It starts i at 0, keeps going while i is less than the length, and adds one each time round. For a 3-slot array that gives 0, 1, 2 and then stops — exactly slots 0 to 2, no overshoot. i < pets.length is the safe form. Write it that way every time and the crash above can never happen.

The second loop is new. Read the colon as the word "in": for each String called pet in pets. It's the for-each loop, and it hands you the values one at a time. No i, no length, no brackets — so no way to fall off the end. It cannot produce an out-of-bounds crash. That's not a small thing.

-- counting for loop --
0: cat
1: dog
2: rat
-- for-each loop --
cat
dog
rat

Both loops printed the same three pets. Only the first one could print the numbers next to them.

So which one? One question decides it: do I need to know the slot number? Printing a numbered list needs i. So does comparing a slot with the one before it. So does writing values into the array. Use the counting loop for all three. Only looking at each value in turn? Use for-each.

A grid is an array of arrays

A street of houses is one line. What if you want a chess board? Put an array in every slot of another array, so each slot holds a whole row.

String[][] board = {
    {"X", "O", "X"},
    {"O", "X", "O"},
    {"X", "O", "X"}
};

System.out.println("board[0][2] is " + board[0][2]);
System.out.println("rows: " + board.length);
System.out.println("columns in row 0: " + board[0].length);

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

String[][] — two pairs of brackets — means "a row of rows". The three inner {…} groups are the three rows. board[0][2] reads as "row 0, then item 2 of that row". board.length is the number of rows. board[0].length is the length of row 0, so the number of columns.

Then two loops, one inside the other. The outer picks a row. The inner walks across it, printing each cell with print. Unlike println, print doesn't move to a new line. The empty System.out.println() ends each row's line.

board[0][2] is X
rows: 3
columns in row 0: 3
XOX
OXO
XOX

Section 4Check yourself

Section 5What broke, and what surprised you

Open a plain text file and note anything from this chapter where your prediction and reality parted ways. Especially:

• Did you expect a fresh String[] to hold empty values rather than null?
• Did you guess the crash message would name line 11, or line 6? Both are in there. Do you know why?
• Did the index drill catch you out, even once, after you'd read the explanation twice?
• Did you expect nine letters on one line from Grid, or three lines of three?

Those aren't trivia. Every one of them is a mistake that will cost you real time later. And you now have the three moves that arrays are made of. Build a row of slots. Reach into any one by its number. Walk all of them with the loop that fits.

Next chapter takes the same idea somewhere strange. Text turns out to be a row of numbered slots too. And it behaves in a way that catches almost everybody.