while Loops

Suppose a running app must announce each lap of a five-lap race. With only the tools from Unit 1, you would write one print statement per lap:

System.out.println("Lap 1");
System.out.println("Lap 2");
System.out.println("Lap 3");
System.out.println("Lap 4");
System.out.println("Lap 5");

It prints Lap 1 through Lap 5, one per line. That works for five laps. Now imagine a marathon training run of 40 laps, or a race where the runner chooses the number of laps before starting. Copying the line 40 times is tedious and easy to get wrong, and if the number of laps is not known when you write the program, no fixed number of copies can be right.

In Topic 2.1 you met repetition in everyday algorithms: “keep stirring until the sauce thickens,” “keep walking laps until you have done five.” The step is written once, and a decision about whether to do it again is made each time. Java needs the same thing: a way to write a step once and have it run again and again as long as some condition holds.

Repeating a segment of code is called iteration. A statement that does this is an iteration statement, usually called a loop. A loop changes the flow of control, the order in which Java runs statements. Normally Java runs statements top to bottom, each one once. A loop sends Java back up to run the same statements again, as long as a boolean expression is true.

Java’s simplest loop is the while loop. Here is the five-lap program written with one:

int lap = 1;
while (lap <= 5)
{
    System.out.println("Lap " + lap);
    lap++;
}
System.out.println("Race over");

Take the loop apart piece by piece:

Read line 2 aloud as “while lap is at most 5, do the body.” The shape is the same as an if statement from Topic 2.3: keyword, condition in parentheses, block in braces. The difference is what happens after the block. An if runs its block at most once and moves on. A while loop goes back to the condition and asks again.

One run through the loop body is called an iteration. This loop does five iterations, one for each value of lap from 1 to 5. Look at the work the variable lap does: it starts at 1 before the loop (line 1), the condition tests it (line 2), the body prints it and adds 1 to it (lines 4 and 5). That start, test, and update are what make the loop stop at the right time.

Lap 1
Lap 2
Lap 3
Lap 4
Lap 5
Race over

Now vary two things: count down instead of up, and use > instead of <=.

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

3
2
1
Liftoff!

int lap = 1;
if (lap <= 5)
{
    System.out.println("Lap " + lap);
    lap++;
}
System.out.println("Race over");

Lap 1
Race over

int lap = 1;
while (lap = 5)
{
    System.out.println("Lap " + lap);
    lap++;
}

error: incompatible types: int cannot be converted to boolean

int step = 2;
while (step <= 8)
{
    System.out.println(step);
    step += 3;
}

To trace loops correctly you need a precise picture of the order Java follows. A common mental picture is “the loop keeps going until the condition becomes false,” and it leads to mistakes, because it does not say when the condition is looked at.

Here is the exact order. Java evaluates the condition before each iteration, including the very first one:

1. Evaluate the condition.
2. If it is true, run the whole body, top to bottom, then go back to step 1.
3. If it is false, skip the body and continue with the first statement after the loop. The loop is over; this is called terminating the loop.

Think of a ticket checker at the entrance to a ride. Each time around, a rider must show a valid ticket at the gate before boarding. Once on the ride, the rider stays on until the ride ends, even if the ticket expires halfway through. The gate (the condition) is checked only at the entrance (the top of the loop).

Two facts follow from this order:

• The condition is checked one more time than the body runs. The extra, final check is the one that comes out false.
• When a loop ends, its condition is false. Whatever variables the condition uses hold the first values that made it fail.

int bacteria = 1;
while (bacteria < 20)
{
    bacteria *= 2;
}
System.out.println(bacteria);

32

Now vary it: track two variables, one that the condition tests and one that counts how many iterations happen.

int temperature = 95;
int minutes = 0;
while (temperature > 70)
{
    temperature -= 8;
    minutes++;
}
System.out.println("Minutes: " + minutes);
System.out.println("Temperature: " + temperature);

Minutes: 4
Temperature: 63

int pages = 10;
while (pages > 0)
{
    pages -= 4;
    System.out.println("Pages left: " + pages);
}

Pages left: 6
Pages left: 2
Pages left: -2

int tickets = 13;
while (tickets >= 5)
{
    tickets -= 5;
    System.out.println(tickets);
}
System.out.println("Done");

8
3
Done

int value = 1;
while (value < 100)
{
    value *= 3;
}
System.out.println(value);

Since the condition is checked before the first iteration too, ask: what if it is already false the very first time? Then the body is skipped completely. A while loop can run its body zero times.

This is not a flaw. It is often what you want. Picture a coffee station that should have 8 cups ready. A helper’s rule is “while there are fewer than 8 cups, pour another.” If 10 cups are already there, the right number of pours is zero. Any rule that always poured at least once would be wrong.

So a loop runs its body zero or more times: zero when the condition starts out false, and some number of times otherwise. Compare this with the if statement from Topic 2.3:

int cups = 10;
while (cups < 8)
{
    System.out.println("Pour a cup");
    cups++;
}
System.out.println("Cups ready: " + cups);

Cups ready: 10

Now change only the starting value, from 10 to 6.

int cups = 6;
while (cups < 8)
{
    System.out.println("Pour a cup");
    cups++;
}
System.out.println("Cups ready: " + cups);

Pour a cup
Pour a cup
Cups ready: 8

int count = 1;
while (count <= 3)
{
    System.out.println("Warm-up " + count);
    count++;
}
while (count <= 2)
{
    System.out.println("Cool-down " + count);
    count++;
}
System.out.println("Workout finished");

Warm-up 1
Warm-up 2
Warm-up 3
Workout finished

int count = 1;
while (count <= 3)
{
    System.out.println("Warm-up " + count);
    count++;
}
count = 1;
while (count <= 2)
{
    System.out.println("Cool-down " + count);
    count++;
}
System.out.println("Workout finished");

Warm-up 1
Warm-up 2
Warm-up 3
Cool-down 1
Cool-down 2
Workout finished

Every loop so far ended because the body changed a variable until the condition became false. What if that never happens? Then the condition is true at every check, the body repeats forever, and the statement after the loop is never reached. This is an infinite loop: a loop whose condition always evaluates to true.

A program stuck in an infinite loop does not crash with an error message. It keeps running. Depending on the body, it may flood the screen with the same line over and over, or show nothing at all and seem frozen. You have to stop it yourself, with the stop button in your coding environment or by pressing Ctrl+C in a terminal. Some online tools stop a program automatically after a time limit.

Because these programs never finish, the code in this subsection is shown without output. Each one is explained by reasoning about the condition, which is exactly how you will spot them on paper.

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

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

Lap 1
Lap 2
Lap 3

The update can also be present but still never make the condition false. Here are three more ways that happens.

The update moves the wrong way. This countdown adds instead of subtracting:

int seconds = 3;
while (seconds > 0)
{
    System.out.println(seconds);
    seconds++;
}

seconds goes 3, 4, 5, 6, …, moving away from 0, so seconds > 0 keeps coming out true. (Strictly speaking, an int cannot grow forever. After about two billion iterations, seconds would pass the largest int and wrap around to a negative number, the integer overflow from Topic 1.5, and the loop would end with a nonsense value. Either way the loop is broken; treat it as infinite.) The fix is seconds--;, as in the countdown in 2.7.1.

The update skips over the stopping value. A condition written with != stops only when the variable lands exactly on one value:

int distance = 7;
while (distance != 0)
{
    distance -= 2;
}

distance goes 7, 5, 3, 1, -1, -3, …. It jumps from 1 straight to -1 and is never equal to 0, so distance != 0 is always true. Every value is odd, and subtracting 2 from an odd number always gives another odd number, so not even overflow rescues it. Using > instead of != catches every value past the stopping point:

int distance = 7;
while (distance > 0)
{
    distance -= 2;
}
System.out.println(distance);

This prints -1: the loop ends at the first value that is not greater than 0.

The update is outside the body. Braces decide what the body is, not indentation. Without braces, only the one statement right after the condition is the body:

int laps = 0;
while (laps < 3)
    System.out.println("Swim a lap");
    laps++;
System.out.println("Pool closed");

The indentation suggests that laps++; belongs to the loop, but Java ignores indentation. The body is only the print statement, so laps stays 0, and Swim a lap repeats forever. laps++; and Pool closed would run only after the loop, which never comes.

A related slip is a semicolon right after the condition:

int laps = 0;
while (laps < 3);
{
    System.out.println("Swim a lap");
    laps++;
}

That ; is an empty statement, and it becomes the whole loop body. Java checks laps < 3, does nothing, checks again, does nothing, forever. The block in braces below it never runs, so this program prints nothing and seems frozen. The fix for both slips is the same: no semicolon after the condition, and braces around every statement that should repeat. Always using braces, even for a one-line body, prevents both mistakes.

int laps = 0;
while (laps < 3)
{
    System.out.println("Swim a lap");
}
laps++;
System.out.println("Pool closed");

int laps = 0;
while (laps < 3)
{
    System.out.println("Swim a lap");
    laps++;
}
System.out.println("Pool closed");

A loop can end, and still be wrong by exactly one iteration. Maybe it prints laps 1 through 4 when you wanted 1 through 5, or six numbers when you wanted five. This is so common that it has a name: an off-by-one error is when a loop runs one time too many or one time too few.

Off-by-one errors come from the edges of the loop: the starting value, whether the condition uses < or <= (or > or >=), and where the update sits in the body. The middle iterations are almost always fine. That tells you where to look: check the first iteration and the last iteration.

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

Lap 1
Lap 2
Lap 3
Lap 4

Now vary the other edge: the starting value.

int lap = 0;
while (lap <= 5)
{
    System.out.println("Lap " + lap);
    lap++;
}

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

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

Lap 2
Lap 3
Lap 4
Lap 5
Lap 6

int lap = 0;
while (lap < 5)
{
    lap++;
    System.out.println("Lap " + lap);
}

Lap 1
Lap 2
Lap 3
Lap 4
Lap 5

int jump = 3;
while (jump <= 10)
{
    System.out.println("Hop!");
    jump++;
}

int n = 10;
while (n > 1)
{
    System.out.println(n);
    n--;
}

while (n >= 1)

Every loop in this chapter so far could be described as “do this N times.” But look back at the cooling tea in 2.7.2. Nobody told the program “repeat 4 times.” It was told “repeat while the tea is hotter than 70,” and the 4 came out of the loop. That is the real power of a while loop: it keeps going until something is achieved, even when you do not know in advance how many steps that takes.

That gives you a way to decide when a task needs a loop at all. A task needs iteration when a step must be repeated, and especially when the number of repetitions depends on data or on how a process unfolds: “keep asking until the answer is valid,” “keep halving until it is small enough,” “keep reading scores until the end marker.” If a step happens once, or if the decision is made just once, a plain statement or an if is enough.

int height = 100;
int bounces = 0;
while (height >= 10)
{
    height /= 2;
    bounces++;
}
System.out.println("Bounces: " + bounces);
System.out.println("Final height: " + height);

Bounces: 4
Final height: 6

Now a different kind of stopping condition: stop when a special value shows up in the input. A value whose only job is to mark the end of the data is often called a sentinel. Here the sentinel is -1, which can never be a real score. The Scanner is built from a string, as in Topic 1.4, so the output is predictable; reading from the keyboard works the same way.

import java.util.Scanner;

public class ScoresUntilStop
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("12 7 30 -1 99");
        int score = input.nextInt();
        while (score != -1)
        {
            System.out.println("Score: " + score);
            score = input.nextInt();
        }
        System.out.println("End of scores");
    }
}

Score: 12
Score: 7
Score: 30
End of scores

import java.util.Scanner;

public class ScoresReadFirstWrong
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("12 7 30 -1 99");
        int score = input.nextInt();
        while (score != -1)
        {
            score = input.nextInt();
            System.out.println("Score: " + score);
        }
        System.out.println("End of scores");
    }
}

Score: 7
Score: 30
Score: -1
End of scores

int heightCm = 3;
int weeks = 0;
while (heightCm < 20)
{
    heightCm += 4;
    weeks++;
}
System.out.println(weeks + " weeks, " + heightCm + " cm");

This program combines a loop with an if statement inside its body (Topic 2.3) and a compound condition (Topic 2.5). A hiker starts with 20 units of energy. Each mile uses 6 units. The hike continues while the hiker has energy left and has walked fewer than 6 miles. After each mile, the program prints the mile number, adding : tired once energy drops below 10.

int energy = 20;
int miles = 0;
while (energy > 0 && miles < 6)
{
    miles++;
    energy -= 6;
    if (energy < 10)
    {
        System.out.println("Mile " + miles + ": tired");
    }
    else
    {
        System.out.println("Mile " + miles);
    }
}
System.out.println("Miles: " + miles + ", energy: " + energy);

Mile 1
Mile 2: tired
Mile 3: tired
Mile 4: tired
Miles: 4, energy: -4

• A while loop repeats its body as long as its boolean condition is true. Use one when a step must repeat, especially when the number of repetitions is not known in advance.
• Java checks the condition before every iteration, including the first. If it is true, the whole body runs; if it is false, the loop ends and Java continues after it. The condition is checked once more than the body runs, and a loop ends at the first value that fails the test.
• If the condition is false at the very first check, the body runs zero times. How many times a loop runs depends on its variables’ values when it starts.
• An infinite loop has a condition that is true every time it is checked: the update is missing, moves the wrong way, skips over a != stopping value, or sits outside the braces.
• An off-by-one error runs a loop one time too many or too few. Check the edges: the starting value, < versus <=, and the order of statements in the body.
• Trace tables, with a column for the condition, are the main tool for following any loop step by step.

int low = 1;
int high = 20;
while (low < high && high > 10)
{
    low *= 2;
    high -= 3;
}
System.out.println(low + " " + high);

int temp = 50;
while (temp < 80)
{
    if (temp < 65)
    {
        temp += 10;
    }
    else
    {
        temp += 4;
    }
    System.out.println(temp);
}

int page = 2;
while (page < 12)
{
    System.out.println("Page " + page);
    page += 2;
}

while (page <= 12)

import java.util.Scanner;

public class RevWordLengths
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("hop skip stop jump");
        String word = input.next();
        while (!word.equals("stop"))
        {
            System.out.println(word.length());
            word = input.next();
        }
        System.out.println("Stopped");
    }
}

3
4
Stopped

import java.util.Scanner;

public class RevSentinelFirst
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("-1 12 7");
        int score = input.nextInt();
        while (score != -1)
        {
            System.out.println("Score: " + score);
            score = input.nextInt();
        }
        System.out.println("End of scores");
    }
}

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

• I can name the condition and the body of a while loop and explain how it differs from an if statement. Reread
• I can trace a while loop with a trace table, including the final check that ends it. Reread
• I can explain why a while loop may run zero times and describe the starting values a loop needs. Reread
• I can spot an infinite loop and explain how to fix it. Reread
• I can find and fix an off-by-one error by checking the first and last iterations. Reread
• I can recognize when a task needs a loop and read a loop that stops on a sentinel value. Reread