for Loops

Many loops count. A program prints seat numbers 1 through 30, runs a game for 10 rounds, or counts down from 3 to liftoff. In Topic 2.7 you wrote counting loops with while. Here is one that prints 1 through 5:

int count = 1;
while (count <= 5)
{
    System.out.println(count);
    count++;
}

1
2
3
4
5

Look at what it takes to make this loop count. Three separate pieces control it, and they sit in three different places:

• line 1 gives the counter its starting value, before the loop;
• line 2 holds the test that decides whether another pass happens;
• line 5 changes the counter, at the very bottom of the body.

All three must be right, or the loop goes wrong. If line 5 is forgotten, count stays 1 forever and the loop never ends, the infinite loop from Topic 2.7. In a longer body, line 5 can be many lines away from line 2, so it is easy to lose track of how the loop moves.

Because counting loops are so common, Java has a loop that gathers all three pieces onto one line. Here is the same loop written that way:

for (int count = 1; count <= 5; count++)
{
    System.out.println(count);
}

It prints exactly the same five lines. The setup, the test, and the change now sit together on line 1, so you can read how the loop counts at a glance: start at 1, keep going while count <= 5, and add 1 each time.

This is a for loop: a loop statement whose header holds the setup, the test, and the update of the loop in one place. Like a while loop, it is a kind of iterative statement, a statement that repeats a block of code. The first line, from for to the closing parenthesis, is the loop header. The statements between the braces are the loop body, the code that repeats, just as in a while loop.

Inside the parentheses, the header has exactly three parts, separated by two semicolons:

for (int count = 1; count <= 5; count++)

The initialization is the first part of the header; it sets up the variable that controls the loop. The Boolean expression (often called the loop’s condition) is the second part, and it works exactly like the condition of a while loop. The update is the third part; it changes the variable, usually by counting up or down.

The variable created in the initialization is the loop control variable. Its value controls how many times the loop runs, because the test checks it and the update changes it. In this loop the loop control variable is count.

A few details of the syntax matter:

• The two separators are semicolons, the same symbol that ends a statement. They are not commas.
• The update has no semicolon after it, even though count++; needs one as a statement on its own line. The closing parenthesis ends the header, and the body follows directly, with no semicolon in between (2.8.2 shows what goes wrong if you add one).
• The body goes in braces, exactly like a while loop’s body.

for (int lap = 1; lap <= 3; lap++)
{
    System.out.println("Lap " + lap + " done");
}
System.out.println("Race over");

Lap 1 done
Lap 2 done
Lap 3 done
Race over

for (int count = 1, count <= 5, count++)
{
    System.out.println(count);
}

error: ';' expected

for (int floor = 10; floor > 0; floor -= 3)

for (int stars = 1; stars <= 4; stars++)
{
    System.out.println(stars * 10);
}

10
20
30
40

The header lists its three parts left to right, but Java does not run them left to right once and then move on. If you misread the order, you will get the wrong output when you trace. So it is worth learning the exact sequence.

Think of a coach running laps with a team. Before practice starts, the coach sets the lap counter to 1, once. Then, before every lap, the coach checks: “Have we done enough?” If not, the team runs a full lap. Only after the lap is finished does the coach add one to the counter. Then the coach checks again. The counter is never changed in the middle of a lap.

A for loop works the same way:

1. Initialization, once. Java runs the first part of the header a single time, before anything else. It never runs again during this loop.
2. Test. Java evaluates the Boolean expression right away. If it is false, the loop is over: Java skips the body and continues with the statement after the loop.
3. Body. If the test was true, Java runs the entire body, top to bottom.
4. Update. Only after the whole body has finished, Java runs the third part of the header.
5. Back to step 2. Java tests again with the updated value, and the cycle repeats until the test is false.

Written as a sequence for a loop that runs its body twice:

initialization → test (true) → body → update
               → test (true) → body → update
               → test (false) → statement after the loop

Notice two things. The update happens at the end of each pass, never before the body. And the test always runs one more time than the body: the final test is the one that comes out false and stops the loop. Each run of the body is called an iteration, so “the loop iterates three times” means the body runs three times.

for (int day = 1; day <= 3; day++)
{
    System.out.println("Day " + day);
}
System.out.println("Done");

Day 1
Day 2
Day 3
Done

Now change one thing: make the test false from the very start. In Topic 2.7 you saw that a while loop whose condition is false at the start never runs its body. A for loop behaves the same way, because the test comes before the first pass.

int guests = 0;
for (int guest = 1; guest <= guests; guest++)
{
    System.out.println("Welcome, guest " + guest);
}
System.out.println("Guest list finished");

Guest list finished

for (int round = 1; round <= 3; round++);
{
    System.out.println("Ding!");
}

Ding!

for (int round = 1; round <= 3; round++)
{
    System.out.println("Ding!");
}

for (int page = 2; page <= 6; page += 2)
{
    System.out.println(page);
}

for (int step = 1; step <= 3; step++)
{
    System.out.println("Start " + step);
    System.out.println("End " + step);
}

Start 1
End 1
Start 2
End 2
Start 3
End 3

Not every loop counts 1, 2, 3 up to some number. A countdown goes backward. A program that prints even numbers jumps by 2. Because each part of the header is an ordinary piece of Java, you can change any of the three to make the loop count the way you need:

• the initialization decides where the counting starts;
• the Boolean expression decides where it stops;
• the update decides how big each step is and in which direction.

The order of execution from 2.8.2 does not change. Only the values do.

for (int countdown = 3; countdown >= 1; countdown--)
{
    System.out.println(countdown);
}
System.out.println("Liftoff!");

3
2
1
Liftoff!

Now vary only the step: count up, but by 2 instead of 1. Any update from Topic 1.6 works, such as += 2.

for (int num = 2; num <= 10; num += 2)
{
    System.out.println(num);
}

Counting how many times a loop runs

To predict output, you often need to know how many times the body runs. Programmers frequently name a plain counting variable i, and many loops start at 0. Compare these three loops, which differ only in their start value and in < versus <=:

for (int i = 0; i < 5; i++)
{
    System.out.print(i + " ");
}
System.out.println();
for (int i = 0; i <= 5; i++)
{
    System.out.print(i + " ");
}
System.out.println();
for (int i = 1; i <= 5; i++)
{
    System.out.print(i + " ");
}
System.out.println();

0 1 2 3 4
0 1 2 3 4 5
1 2 3 4 5

(Each System.out.println() with nothing in the parentheses just ends the line of output.)

When a loop adds 1 each time, you can count without listing every value:

• With <, the stop value itself is left out, so the loop runs stop − start times. 0 up to but not including 5 is 5 − 0 = 5 times.
• With <=, the stop value is included, so it runs stop − start + 1 times. 0 through 5 is 5 − 0 + 1 = 6 times.

For a loop that steps by more than 1, or counts down, list the values in a short table as in the examples above. That always works.

for (int page = 1; page < 5; page++)
{
    System.out.println("Printing page " + page);
}

Printing page 1
Printing page 2
Printing page 3
Printing page 4

for (int page = 1; page <= 5; page++)
{
    System.out.println("Printing page " + page);
}

A different kind of mistake makes the test impossible to turn false. In this loop the variable starts at 1 and goes up by 2, so it is always odd. It can never equal 10, so odd != 10 is always true, and the loop is an infinite loop:

for (int odd = 1; odd != 10; odd += 2)
{
    System.out.println(odd);
}

Before you run a loop, check that its update moves the loop control variable toward a value that makes the test false.

for (int seat = 0; seat <= 10; seat++)
{
    System.out.println("Seat " + seat);
}

for (int coins = 1; coins < 40; coins *= 3)
{
    System.out.println(coins);
}

1
3
9
27

You now have two loops. Are they really different tools? Not in what they can do: any for loop can be rewritten as a while loop that does exactly the same thing, and any while loop can be rewritten as a for loop. Knowing how to switch between them helps you read code written either way, and it explains what the for loop is doing behind the scenes.

Go back to the order from 2.8.2: initialization once, then test, body, update, repeated. A while loop can follow that same order if you put each piece in the right place. Here is the general shape of a for loop:

for (initialization; test; update)
{
    body
}

And here is the while loop that does the same thing:

initialization;
while (test)
{
    body
    update;
}

• The initialization moves to a statement just before the while loop, so it still runs once.
• The test becomes the while loop’s condition. Both loops check it before every pass.
• The update moves to the last line of the while body, so it still runs after everything else in the body and before the next test. It now needs its own semicolon, because it is a statement.

for (int countdown = 3; countdown >= 1; countdown--)
{
    System.out.println(countdown);
}
System.out.println("Liftoff!");

int countdown = 3;
while (countdown >= 1)
{
    System.out.println(countdown);
    countdown--;
}
System.out.println("Liftoff!");

3
2
1
Liftoff!

The rewrite works in the other direction too. A while loop with a clear starting value, a test, and an update as its last statement can become a for loop. This one halves a number each pass:

int size = 64;
while (size > 1)
{
    System.out.println(size);
    size /= 2;
}

for (int size = 64; size > 1; size /= 2)
{
    System.out.println(size);
}

64
32
16
8
4
2

So which should you use? Either one works, but a for loop is the natural choice when the loop is controlled by a counter that starts, stops, and steps in a way you know ahead of time, because the whole plan sits in the header. A while loop reads more naturally when there is no counter, for example “keep going until the balance drops below zero.”

int count = 1;
while (count <= 5)
{
    count++;
    System.out.println(count);
}

2
3
4
5
6

int count = 1;
while (count <= 5)
{
    System.out.println(count);
}

for (int lap = 1; lap <= 3; lap++)
{
    System.out.println("Lap " + lap);
}
System.out.println("Laps run: " + lap);

error: cannot find symbol
  symbol:   variable lap

int lap = 1;
while (lap <= 3)
{
    System.out.println("Lap " + lap);
    lap++;
}
System.out.println("Final value of lap: " + lap);

Lap 1
Lap 2
Lap 3
Final value of lap: 4

int lives = 3;
while (lives > 0)
{
    System.out.println("Lives: " + lives);
    lives--;
}

int ticket = 1;
while (ticket <= 4)
{
    System.out.println("Ticket " + ticket);
}

int ticket = 1;
while (ticket <= 4)
{
    System.out.println("Ticket " + ticket);
    ticket++;
}

This program follows a runner through four laps of a 400-meter track. It uses a for loop with an if statement (Topic 2.3) inside its body and keeps a running total. Before reading the trace, predict all five lines of output.

public class TrackPractice
{
    public static void main(String[] args)
    {
        int totalMeters = 0;
        for (int lap = 1; lap <= 4; lap++)
        {
            totalMeters += 400;
            if (lap % 2 == 0)
            {
                System.out.println("Lap " + lap + ": water break");
            }
            else
            {
                System.out.println("Lap " + lap + ": keep going");
            }
        }
        System.out.println("Total meters: " + totalMeters);
    }
}

Lap 1: keep going
Lap 2: water break
Lap 3: keep going
Lap 4: water break
Total meters: 1600

• A for loop puts the three things that control a counting loop in one header, separated by semicolons: the initialization, the Boolean expression, and the update. The variable the initialization sets up is the loop control variable.
• The initialization runs only once. Then the loop repeats: test, whole body, update. The update always comes after the entire body and before the next test, and the test runs one more time than the body. If the test is false at the start, the body runs zero times.
• Changing the start value, the test, or the update changes where a loop starts, where it stops, and how it steps. With a step of 1, < leaves out the stop value and <= includes it; mixing them up causes off by one errors.
• Every for loop can be rewritten as a while loop by putting the initialization before the loop, using the test as the condition, and making the update the last statement in the body, and a counting while loop can be rewritten as a for loop the same way in reverse.
• A variable declared in a for loop header exists only inside that loop. A stray semicolon after the header makes the loop body empty.

for (int k = 3; k <= 12; k += 3)
{
    System.out.println("Hi");
}

int total = 0;
for (int n = 10; n > 0; n -= 4)
{
    total += n;
    System.out.println(n + " " + total);
}

10 10
6 16
2 18

for (int x = 5; x < 20; x += 5)
{
    System.out.println(x);
}

int x = 5;
while (x < 20)
{
    x += 5;
    System.out.println(x);
}

int x = 5;
while (x < 20)
{
    System.out.println(x);
    x += 5;
}

int x = 0;
while (x < 20)
{
    System.out.println(x);
    x += 5;
}

int x = 5;
while (x > 20)
{
    System.out.println(x);
    x += 5;
}

for (int num = 10; num > 2; num -= 2)
{
    System.out.println(num);
}

for (int num = 10; num >= 2; num -= 2)
{
    System.out.println(num);
}

int count = 0;
while (count < 3)
{
    count++;
    System.out.println(count);
}

for (int count = 0; count < 3; count++)
{
    System.out.println(count);
}

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can name the initialization, Boolean expression, and update in a for loop header. Reread
• I can trace a for loop in order: initialization once, then test, body, update. Reread
• I can change where a for loop starts, stops, and steps, and count its iterations. Reread
• I can spot and fix an off by one error caused by < versus <=. Reread
• I can rewrite a for loop as a while loop, and a counting while loop as a for loop. Reread