Skip to main content

Computational Problem Solving with Java and Interactive Object Graphics

Mark F. Russo, PhD

Section 5.3 while-Statements

Our second Java control statement for this chapter is the while-statement. This statement gives us a way to perform iteration, the second major program flow control technique. Recall that the if-statement gives us branching, the first flow control technique. With the while-statement we now have a second way to control program flow.
The while-statement executes a block of code — while — a condition continues to evaluate to true. More specifically, when a while-statement is encountered at runtime, the condition is evaluated. If true, the code block is executed, and the condition is evaluated again. If it remains true, the code block is executed again. This repeats until the condition evaluates to false. Compare this to the if-statement, which executes a block of code once, at most, if a condition evaluates to true. Otherise the code block is skipped. Either way, program control continues immediately after the if-statement.
The structure of a while-statement is nearly identical to an if-statement, the only difference being that the if keyword is replace by the while keyword. Otherwise, the structure is the same.
Figure 5.3.1. Parts of a while-Statement

Subsection 5.3.1 While with a Counter

One of the most common ways to use the while-statement is to execute its block of code a fixed number of times. We can accomplish this by adding a counter variable to the while-statement. The counter variable is declared and initialized before the loop, usually to 0, and it is incremented by 1 each time the code block is executed. The while-statement’s condition tests the value of the counter. When it meets or exceeds some maximum value, the condition evaluates to false and the while-statement stops iteration.
Listing 5.3.2 is an example program that makes use of this strategy.
// WhileCounter.java
public class WhileCounter {
  public static void main(String[] args) {
    int i = 0;                  // Init i to 0
    while (i < 5) {             // Test if i has exceeded max counts
      System.out.println(i);    // Print the current value of i
      i++;                      // Increment i by 1
    }
    System.out.println("Done"); // First line after the while
  }
}
Listing 5.3.2. While-statement with a counter
When we compile and run this program, we see the following output.
javac WhileCounter.java
java WhileCounter
0
1
2
3
4
Done
The variable i is declared and initialized to 0. The while-statement condition continues to run while the value of i remains less than 5. Each time the while-statement code block executes, it prints the current value of i and then increments the value of i by 1.
As expected, 0 is printed first, followed by 1, 2, etc. as i is incremented. The last value printed is 4. After 4 the value of i increments to 5, and then the condition is tested. Because 5 < 5 evaluates to false, iteration stops and control continues with the first line after the while-statement, which prints "Done".
Constructing a while-statement for counting involves the addition of three important elements:
  1. A counter is declared and initialized before the while-statement.
  2. The counter is incremented within the block of code associated with the while-statement.
  3. The while-statement’s conditional expression checks if the counter exceeds some value and stops.
We will see these same three important elements resurface when we continue our exploration of iteration.

Subsection 5.3.2 Counter Variations

Nothing prevents us from defining the way a while-statement counts. There is no requirement that we count up by 1 for each iteration. We might count up by 2, or count down by 1. Also, there is nothing to say what we use as the test for when a while-statement should stop iterating. We might want to change the way a while-statement operates when we have a secondary use for the counter variable.
Listing 5.3.3 is a program that prints a countdown sequence to the launch of a rocket.
// Liftoff.java
public class Liftoff {
  public static void main(String[] args) {
    int count = 10;                     // Init counter
    while ( count >= 0 ) {              // Continue while i >= 0
      System.out.println(count);        // Print countdown
      count--;                          // Decrement i
    }
    System.out.println("Lift off!");    // Once we hit 0, lift off
  }
}
Listing 5.3.3. Listoff.java
Compiling and running Listing 5.3.3, we see the following output.
javac Liftoff.java
java Liftoff
10
9
8
7
6
5
4
3
2
1
0
Lift off!
In another application, we might want to print the number of feet and remaining inches from the edge of a wall where studs should be placed. Typically, wall studs are placed at a 16 inch spacing from center to center. Let’s write a program that prints the location for all studs on a 12 foot wall measured in feet plus remaining inches. To solve this problem we count up position by 16 inches, but use integer division and modulo to convert to feet and remaining inches before printing.
// Studs.java
public class Studs {
  public static void main(String[] args) {
    int feet, inches;                   // Temp variables
    int width = 12*12;                  // Width of wall in inches
    int position = 0;                   // First stud position
    while ( position <= width  ) {      // Keep going while less that width
      feet = position / 12;             // Compute feet and remaining inches
      inches = position % 12;           // Print results
      System.out.println(feet + " ft " + inches + " in");
      position += 16;                   // Increment position
    }
  }
}
Listing 5.3.4. Studs.java
After compiling and running this program, we see the following output stud positions.
javac Studs.java
java Studs
0 ft 0 in
1 ft 4 in
2 ft 8 in
4 ft 0 in
5 ft 4 in
6 ft 8 in
8 ft 0 in
9 ft 4 in
10 ft 8 in
12 ft 0 in
Iteraton is just one technique which can be used alone or combined with branching and other program flow control statements to craft sophisticated computational problem solutions.
<Prev^TopNext>