Code Help and Videos >

 Java For and While Loops

This handout introduces the basic structure and use of Java for and while loops with example code an exercises. See also the associated CodingBat java loop practice problems using strings and arrays. Written by Nick Parlante.

Java Loop

A while loop has a boolean test and a body containing statements, like this:

int count = 0;
while (count < 100) {  // test: boolean test within (..)
  System.out.println("count:" + count);  // body: statements within {..}
  count = count + 1;	
}
System.out.println("all done!");

1. Check if the test is true or false. If false, the loop "exits" and does not execute the body. If the test is true, continue with step 2.
2. Execute the body statements, starting at the top and proceeding down through them all.
3. Go back to step 1 and check the test again. If it is true, run the body again. Each time the body finishes, "loop around" and check the test again. Each run of the body is called an "iteration" of the loop.

count:0
count:1
count:2
count:3
...
count:98
count:99
all done!

How To Write a While Loop

• test -- a boolean test of what should be true before each iteration. Or put another way, the test is the "green light" condition that says that each iteration can go ahead. (The phrase "green light" is a good mnemonic for what the test does.) Eventually, the test should become false and the loop can exit. Think about the precondition that describes the state before each iteration runs -- how are things arranged, what is true? (Also known as an "invariant".) In the above example, the test (count < 100) means that each iteration can proceed, so long as (count < 100) is true.
• work -- code in the body that does something for each iteration such as printing or drawing something. Some loops do not have any identifiable work in the body. In the above example, the work is the println() that prints something out for each iteration.
• increment -- code in the body that advances things so we are closer to making the test false. At the end of the body, the code will loop around to the top of the body. Sometimes, some cleanup is required at the end of the body to set things up for the next iteration. In the above example, the line "count = count + 1;" accomplishes the increment. That can also be written as "count++;".

While Loop Example

// Given a num, returns how many times can we divide it by 2 to get down to 1.
int count2Div(int num) {
  int count = 0;   // count how many divisions we've done
  while (num >= 1) {
    num = num / 2;
    count++;
  }
  return count;
}

Zero Loop Iterations

int count = 100;
while (count < 100) {	// the test is false the very first time
  count = count + 1		// this line never runs
}

Infinite Loop

int count = 0;
while (count < 100) {
  System.out.println("count:" + count);
  count = count * 1;				// OOPS, does not change count
}

int count = 0;
while (count < 100) {
  System.out.println("count:" + count);
  // OOPS, forget to put in a line that changes count at all
}

count:0
count:0
count:0
count:0
...
--never stops--

while (true) {		// deliberate infinite loop
  ...
  ...
}

Many computer people like to think of themselves as part of a whimsical field that does not take itself too seriously compared to more established disciplines. For example, Apple Computer headquarters is located on "1 Infinite Loop, Cupertino CA".

Loop and a Half - "break"

For example, suppose we have a Frog object that responds to dive() and float() methods that move the frog around in a pond. The frog also responds to an isSunny() method that returns true if the frog is in the sun. We want to write a "find sun" loop that does this: float, check if there is sun. If there is sun, we're done. Otherwise, dive and try the cycle again. So the sequence is float, sun check, dive, float, sun check, dive, .... until the sun check returns true. The key feature here is that the test does not naturally fit at the top of the loop. Instead the test most cleanly goes in the middle of the loop.

The code for this problem demonstrates uses an while-break structure. An if statement in the middle of the while loop checks for the exit condition. If the exit condition is true, the code calls "break" which exits the while loop immediately:

// suppose we have a variable "frog"
while (true) {			// use "true" as test -- exit is handled by the if-break below
  frog.float();

  // Exit using if-break
  // Check for exit condition, and if true call break
  if (frog.isSunny()) {
    break;	// this exits the loop
  }

  frog.dive();
}
// The break exits the loop, leading to this line

while (test) {
  body
}

while (true) {
  if (!(test)) {
    break;
  }
  body
}

Notice that the normal while loop test is a "green light" condition -- if it is true, the loop continues; if it is false the loop exits. With a while-break, the test is the opposite. The while-break test is a "red light" condition. If it is true, the loop exits.

For Loops

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

i:0
i:1
i:2
i:3
i:4
...
i:99

for ( init ; test ; increment ) {
  body
}

The for-loop follows four steps:

1. Init

It is idiomatic to use the variable name "i" for a counter variable. Although we avoid single-letter variable names for general purpose storage, this use of "i" is standard in a for-loop like this. Indeed, this pattern is so standard that other programmers would likely be a little confused if you used a variable name other than "i" in a for-loop. The convention extends to using the names "j", and "k" for loop variables if "i" is already in use. Never use lowercase L "l", since it looks just like the digit one "1" in many fonts.

2. Test

3. Loop-body

4. Increment

In this case, the increment is "i++" which increments the variable "i" by one. Since "i" is the common variable choice for a for-loop, it is very common for the increment to be "i++". It is idiomatic to write the increment as "i++" as opposed to the similar "i = i + 1".

For Loop Examples

/*
 Classic for-loop counting up from 0 to 99
 0, 1, 2, 3, ... 99
-init int i = 0
-test i<100
-increment i++
*/
for (int i=0; i<100; i++) {
  System.out.println(i);
}
	
/*
 For-loop to print the values
 0, 2, 4, 6, .. 98
 -increment by i+=2, instead of i++
  (same as i = i + 2)
*/
for (int i=0; i<100; i+=2) {
  System.out.println(i);
}
	
/*
 For-loop from 99 down to 0
 99, 98, 97, ... 0
 -init i=99
 -test i>=0
 -increment i--
*/
for (int i=99; i>=0; i--) {
  System.out.println(i);
}

/*
 For-loop from 0 to 100 by 5's
 0, 5, 10, 15, .. 100
 -test i<=100
 -increment i+=5
*/
for (int i=0; i<=100; i+=5) {
  System.out.println(i);
}	

Test Style < vs. <=

For vs. While Loops

init
while (test) {
  body
  increment
}

int i = 0;
while (i<100) {
  System.out.println(i);
  i++;
}

Loop With 2 Exit Tests

public int findCode(Vault vault) {
  for (int i=0; i<=1000000; i++) {
    if (vault.tryCode(i)) {
      // found the code!
      return(i);
    }
  }
  return(-1);  // if we get here, we did not find the code
}

Only Test at the Top

count = 0;
while (count < 100) {
  count = count + 10;
  count = count - 10;
  count = count + 1;
}

CodingBat.com code practice. Copyright 2012 Nick Parlante.