Loops and Jump Statements

Exact execution order

For this loop:

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

Java runs setup once. It then repeats condition, body and update. A failed condition ends the loop before the body.

continue in a for loop jumps to the update and then the next condition. break skips both and leaves the loop.

State an invariant

A loop invariant is a fact that is true before and after every completed pass. It makes a loop easier to verify.

int sum = 0;
for (int i = 0; i < 4; i++) {
    sum += i;
}
System.out.println(sum);   // 6

At the condition check, sum equals the sum of integers from 0 up to, but not including, i. It is true at i = 0. The body adds i, and the update advances i, so the fact remains true. When the loop stops at i = 4, the invariant tells us sum is 0 + 1 + 2 + 3.

Where the counter lives

for (int i = 0; i < 5; i++) { }
System.out.println(i);        // ERROR: cannot find symbol

i was declared inside the for header, so it stops existing when the loop ends. That is usually what you want, because it stops one loop’s counter leaking into the next.

If you need the value afterwards, declare it outside:

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

Note that i is 5, not 4. The loop only stopped because the condition failed, which means i had already reached 5.

break and continue

• break leaves the loop completely.
• continue skips the rest of this pass and goes to the next one.

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) continue;    // skip evens
    if (i > 7) break;            // stop entirely
    System.out.println(i);       // 1 3 5 7
}

break only leaves one loop

for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 3; col++) {
        if (grid[row][col] == target) {
            break;              // leaves the col loop only. The row loop keeps going.
        }
    }
}

Three ways to get out of both:

Labelled break is real Java and worth recognising when you read it. In your own code, the method usually reads better.

Common non-terminating loops

Three ways to make a loop that never ends. All three are common.

One: you forget to change the thing the condition tests.

int i = 0;
while (i < 10) {
    System.out.println(i);      // no i++ anywhere
}

Two: you used != on decimals.

for (double d = 0.0; d != 1.0; d += 0.1) { }     // never stops

Look familiar? That is Section 2.2 coming back for you. 0.1 has no exact binary form, so you are not really adding 0.1. After ten additions you land on 0.9999999999999999, which is not equal to 1.0, so the loop sails past it and runs forever.

An ordered bound stops eventually, but may perform a different number of passes from the intended decimal steps:

for (double d = 0.0; d < 1.0; d += 0.1) { }      // terminates, but may run 11 times
for (int i = 0; i < 10; i++) { double d = i * 0.1; }   // exactly ten passes

Prefer the second form when a fixed count controls the work. Count with whole numbers and work out the decimal inside the loop. The displayed decimal can still be approximate, but it does not control termination.

Three: you changed the counter inside the body as well as in the header.

for (int i = 0; i < 10; i++) {
    if (something) i--;         // now the loop may never advance
}

Off by one

The most common loop bug there is, and it comes down to one character.

for (int i = 0; i < 5; i++)    // 0 1 2 3 4  -> five passes
for (int i = 0; i <= 5; i++)   // 0 1 2 3 4 5 -> six passes
for (int i = 1; i <= 5; i++)   // 1 2 3 4 5  -> five passes

The convention that is worth adopting is start at 0 and use <. It matches how arrays are numbered, which you will meet in the very next section, and it makes the count obvious: i < n runs exactly n times.