Introduction: A loop allows you to execute a statement or block of code

repeatedly. The need to repeat a block of code arises in almost every

program. There are three kinds of loop statements you can use, so let's

look at thesein general terms first:

5. Nested Loops

You can nest loops of any kind one inside another to any depth. Let's

look at an example where we can use nested loops.

A factorial of an integer, n, is the product of all the integers from 1 to n.

It is written as n!. It may seem a little strange if you haven't come across

it before, but it can be a very useful value. For instance, n! is the number

of ways you can arrange n different things in sequence, so a deck of cards

can be arranged in 52! different sequences.

Let's try calculating some factorial values.

6. The continue Statement

There are situations where you may want to skip all or part of a loop

iteration. Suppose we want to sum the values of the integers from 1 to

some limit, except that we don't want to include integers that are

multiples of three.

We can do this using an if and a continue statement:

for(int i = 1; i <= limit; i++) {
  if(i % 3 == 0) {
    continue;                    // Skip the rest of this iteration
  }
  sum += i;                     // Add the current value of i to sum
}

The continue statement is executed in this example when i is an exact

multiple of 3, causing the rest of the current loop iteration to be skipped.

Program execution continues with the next iteration if there is one, and

if not, with the statement following the end of the loop block.

The continue statement can appear anywhere within a block of loop

statements. You may even have more than one continue in a loop.

We could add a labeled continue statement to omit the calculation

of factorials of odd numbers greater than 10. This is not the best way

to do this, but it does demonstrate how the labeled continue statement

works:

public class Factorial {
  public static void main(String[] args) {
    long limit = 20;      // to calculate factorial of integers up to this value
    long factorial = 1;   // factorial will be calculated in this variable

    // Loop from 1 to the value of limit
    OuterLoop:
    for(int i = 1; i <= limit; i++) {
      factorial = 1;                   // Initialize factorial
      for(int j = 2; j <= i; j++) {
        if(i > 10 && i % 2 == 1) {
          continue OuterLoop;          // Transfer to the outer loop
        }
        factorial *= j;
      }
      System.out.println(i + "!" + " is " + factorial);
    }
  }
}

8. Using the break Statement in a Loop

We have seen how to use the break statement in a switch block. Its

effect is to exit the switch block and continue execution with the first

 statement after the switch. You can also use the break statement to

break out from a loop when you need. When break is executed within

a loop, the loop ends immediately and execution continues with the

first statement following the loop. To demonstrate this we will write

a program to find prime numbers.

In case you have forgotten, a prime number is an integer that is not

exactly divisible by any number less than itself, other than 1 of course.

public class Primes {
  public static void main(String[] args) {
    int nValues = 50;                // The maximum value to be checked
    boolean isPrime = true;               // Is true if we find a prime

    // Check all values from 2 to nValues
    for(int i = 2; i <= nValues; i++) {

      isPrime=true;                    // Assume the current i is prime

      // Try dividing by all integers from 2 to i-1
      for(int j = 2; j < i; j++) {
        if(i % j == 0) {        // This is true if j divides exactly
          isPrime = false;  // If we got here, it was an exact division
          break;              // so exit the loop
        }
      }

   // We can get here through the break, or through completing the loop
      if(isPrime)                  // So is it prime?
        System.out.println(i);    // Yes, so output the value
      }
    }
  }
}

9. The Labeled break Statement

Java also makes a labeled break statement available to you.

This enables you to jump immediately to the statement following the

end of any enclosing statement block or loop that is identified by the

label in the labeled break statement. This mechanism is illustrated in

the following diagram:

The labeled break enables you to break out to the statement following an

enclosing block or loop that has a label regardless of how many levels there

are. You might have several loops nested one within the other, and using the

labeled break you could exit from the innermost loop (or indeed any of them)

to the statement following the outermost loop. You just need to add a label

to the beginning of the relevant block or loop that you want to break out of,

 and use that label in the break statement.

ust to see it working we can alter the previous example to use a labeled break statement:

public class FindPrimes {
  public static void main(String[] args) {
    int nPrimes = 50;                   // The maximum number of primes required

    // Check all values from 2 to nValues
    OuterLoop:
    for(int i = 2; ; i++) {                   // This loop runs forever

      // Try dividing by all integers from 2 to i-1
      for(int j = 2; j < i; j++) {
        if(i % j == 0) {                   // This is true if j divides exactly
          continue OuterLoop;             // so exit the loop
        }
      }
      // We only get here if we have a prime
      System.out.println(i);                  // so output the value
      if(--nPrimes == 0) {                     // Decrement the prime count
        break OuterLoop;                      // It is zero so we have them all
      }
    }
    // break OuterLoop goes to here
  }
}

The program works in exactly the same way as before. The labeled break

ends the loop operation beginning with the label OuterLoop, and so

effectively branches to the point indicated by the comment.

Of course, in this instance its effect is no different from that of an unlabeled

break. However, in general this would work wherever the labeled break

statement was within OuterLoop. For instance, it could be nested inside

another inner loop, and its effect would be just the same – control would be

transferred to the statement following the end of OuterLoop.