Class 13: Loops

Held: Friday, 17 September 2004

Summary: Today we consider loops (non-recursive control structures for repetition) in Java.

Related Pages:

• EBoard.

Due

• Homework 13.

Assignments

• Homework 14: Testing vectors, revisited.

Notes:

• Be careful, class 13 falls on Friday. (It makes it essentially Friday the 13th.)
• Comment from graduated CS/English major: CSC151 and CSC152 were my too hardest classes in the major.

Overview:

• Iterative Repetition.
• While Loops.
• Do Loops.
• For Loops.
• Lab (J5.1 and J5.3).

Switch Statements: A Simple Compound Conditional

• Often, you need to do more than select between a true case and a false case. Instead, you must select between a wider range of cases (most typically, between a series of integers).
• While it is possible to select between multiple values with a sequence of if statements, such a solution is neither readable nor efficient.
• As an alternative, Java provides the switch statement (like the case statement in Pascal).
• It takes the form

  switch (integer-valued-expression) {
    case value1:
      stuff-to-do;
      break;
    case value2:
      stuff-to-do;
      break;
    ...
    default:
      stuff-to-do;
      break;
  }
  

• If you leave out a break, execution will continue into the next case.
• You can switch on expressions whose type is byte, short, int, long, or char.
• Each value must be a constant (or perhaps a constant expression). It cannot depend on run-time computations.
• The break statement has other uses, which you'll see later.

Control Structures for Repetition

• In many algorithms, we want to be able to do the same thing repeatedly.
  • Apply a function to each element of a list.
  • Process information until there is no more information left to process.
  • Beat the mixture 40 times (recipe).
• Rather than repeating the code again and again, we look toward control structures that let us express the repetition concisely and clearly.
  • These are often called loops.
• Most imperative languages provide three kinds of control structures:
  • One looping control structure supports a fixed number of repetitions (beat the mixture 40 times; for each element of this list, do ...). Often, this control structure gives you an associated counter variable.
  • A second looping control structure allows you to repeat an action for as long as a condition holds (as long as there is work left to do ...).
  • A third looping control structure allows you to repeat an action until a condition holds (keep doing work until you've finished the project). Obviously, this can be simulated by the prior structure. (or the prior structure can be simulated with this one.
• We'll look at how Java supports all three.

While Loops

• We'll begin with the second kind of looping structure, because it is the most general.
  • You will use this structure execute a series of statements as long as a condition holds.
• For this case, Java provides while loops, which have the form

  while (test) {
    statements;
  } // while
  next-statement;
  

• In executing this loop, Java evaluates the test. If the test fails, the loop terminates and Java moves on to the next statement. Otherwise, Java executes the statements in the body of the loop and then goes back and tries the test again.
• For example, here's some simple code to read a series of grades and stop when the user enters 0.

      boolean done = false;
      SimpleOutput pen = new SimpleOutput();
      SimpleInput eyes = new SimpleInput();
      int nextGrade = 0;
      int numGrades = 0;
      int sumGrades = 0;
      while (!done) {
        pen.print("Enter the next grade: ");
        nextGrade = eyes.readInt();
        if (nextGrade != 0) {
          sumGrades = sumGrades + nextGrade;
          numGrades = numGrades + 1;
        }
        else {
          done = true;
        }
      } // while (!done)
  

• Note that the testing is only done when the body finishes. If the body makes the test temporarily false and then true again, the loop still continues.
• The done is often called the loop sentinel, a variable upon which repetition of the loop continues.
• We can also write the loop portion a little more concisely by using a continue sentinel.

      int continue = 1;
      while (continue) {
        pen.print("Enter the next grade: ");
        nextGrade = eyes.readInt();
        if (continue = (nextGrade != 0)) {
          sumGrades = sumGrades + nextGrade;
          numGrades = numGrades + 1;
        } // if (continue = (nextGrade != 0)
      } // while (continue)
  

Do Loops

• At times, you will want to have a loop in which the body is executed once before the test. While it is possible to do this by repeating code, it is easier to use a variant of the while loop called the do loop. This variant has the form

  do {
    statements
  } while (test);
  next-statement;
  

  • This is the only time you won't need to comment your ending brace.
• If you only want to execute one (or zero) statements, you don't need the braces. However, I consider it good programming practice to include them.
  • It doesn't change the execution speed of your program.
  • It makes it much easier to extend your program.
  • It does, however, increase the physical length of the code for your program.
• We can use Do loops to simplify the earlier code.

      do {
        pen.print("Enter the next grade: ");
        nextGrade = eyes.readInt();
        if (nextGrade != 0) {
          sumGrades = sumGrades + nextGrade;
          numGrades = numGrades + 1;
        }
      } while (nextGrade != 0);
  

For loops

• At times, you want to execute a statement (or block of statements) a fixed number of times.
• For example, to calculate the factorial of N, we might multiply 1 by the numbers from one to N.
  • Yes, this is a prototypical example.
• We might express this in psueodcode as

    result = 1
    for each value, v, between 1 and N
      multiply result by v, updating result
    return the final result
  

• Many programming languages provide a structure known as the for loop for situations like this.
• Java provides a more general form of the for loop. It has the form

  for (initialization; test; increment) {
    statements;
  } // for
  

• In effect, this is equivalent to

  initialization;
  while (test) {
    statements;
    increment;
  } // while (test)
  

• Any of the four parts of a for loop can be omitted (in which case it is ignored).
• We can then solve our initial factorial problem as follows

    /**
     * Compute n!.
     */
    public int factorial(int n) {
      int i;         // A counter variable
      int factorial; // The factorial of n
      factorial = 1;
      for (i = 1; i <= n; i = i+1) {
        factorial = factorial * i;
      } // for
      return factorial;
    } // factorial(int)
  

• We could also use while loops or recursive procedure calls.

Detour: Shorthand in For Loops

• Most Java programmers increment their counter variables with the preincrement operator, var, or the postincrement operator, var++.

      for (i = 1; i <= n; ++i)
  

• It is also possible (and even encouraged) to declare the counter variable within the for loop, as in

      for (int i = 1; i <= n; ++i)