Class 34: Loops

Held: Tuesday, 1 April 2003

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

Related Pages:

• EBoard.
• Lab J5.

Assignments:

• Read Lab X3 (focus on the section on exceptions).
• Do Homework 3 (due next Tuesday).

Notes:

• Happy April Fools' Day
• Exam 2 Returned. Upon reflection, I realized that partition does not always work correctly (Bad Sam!), so I gave you all full credit for the problem. Please talk to me if you have other questions.

Overview:

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

Review: Conditionals

• Four forms:
  • One-branch If Statements

    if (test) {
      stuff-to-do-if-test-holds;
    } // if (test)
    

  • Two-branch If Statements

    if (test) {
      stuff-to-do-if-test-holds;
    } // if (test)
    else {
      stuff-to-do-if-test-does-not-hold;
    } // if (! test)
    

  • Cascading If Statements

    if (test1) {
      stuff-1;
    }
    else if (test2) {
      stuff-2;
    }
    ...
    else if (testn) {
      stuff-n;
    }
    else {
      default;
    } // if none of the tests hold
    

  • Switch Stateemnts
• Reflection:
  • What are some other ways we might use conditionals with the Rational class that we discussed before break?
  • What are some other ways in which you might expect to use conditionals?

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)
  

Loop Lab

• Lab J5: Control Structures for Repetition
• Try to do experiments J5.1 and J5.3.
  • J5.1 covers while loops.
  • J5.3 covers for loops.
• Reflection
  • What does your count method look like?
  • What is wrong with readPass. How did you fix that problem?