while Loops

Hey there, it's Saavi. Let's talk about one of the most powerful ideas in programming: repetition. So many problems, from simple games to complex data analysis, involve doing something over and over again. In Java, the while loop is one of our primary tools for this.

The Basic Idea: A Conditional Loop

Think of a while loop like a very persistent bouncer at a club.

• There's a rule (a Boolean condition): age >= 21.
• The bouncer checks the rule.
• If it's true, you get to go inside and party (the loop body executes).
• After you're done, you have to go back to the bouncer to get checked again.

As long as the condition is true, the process repeats. The moment the condition becomes false, the party's over, and the program moves on.

The basic structure in Java looks like this:

while (boolean_expression) {
  // Code to be repeated
  // This is called the loop body
}

The boolean_expression is the question the loop asks before every single iteration. If the answer is true, the code inside the curly braces {} runs. If the answer is false, the code inside is skipped entirely, and the program continues with whatever comes after the loop.

The Three Parts of a Loop

To make a while loop work correctly, you almost always need three key ingredients:

1. 1
   Initialization

   You need to set up your variables before the loop starts. This is like setting up the initial state of the world.
2. 2
   Condition

   The Boolean expression that gets checked before each loop iteration.
3. 3
   Update

   Something inside the loop body must change the variable(s) used in the condition. If you forget this, you might create an infinite loop!

Let's see this in action with a countdown for a rocket launch.

// 1. Initialization
int count = 10;

// 2. Condition
while (count > 0) {
  System.out.println(count);

  // 3. Update
  count = count - 1; // or count--;
}

System.out.println("Blast off!");

Let's trace this:

1. count starts at 10.
2. The loop asks: Is count > 0? Is 10 > 0? Yes, it's true.
3. The loop body runs: It prints 10. It then updates count to 9.
4. The loop goes back to the top. Is 9 > 0? Yes, true.
5. It prints 9, updates count to 8.
6. ...This continues until...
7. count is 1. The loop asks: Is 1 > 0? Yes, true.
8. It prints 1, updates count to 0.
9. The loop goes back to the top. Is 0 > 0? No, this is false!
10. The loop terminates. The code inside the {} is skipped, and the program moves on to print "Blast off!".

When the Loop Never Runs

What if the condition is false from the very beginning?

int ticketsLeft = 0;

while (ticketsLeft > 0) {
  // This code will never run
  System.out.println("Selling a ticket!");
  ticketsLeft--;
}

System.out.println("Sold out!");

Here, ticketsLeft starts at 0. The loop condition ticketsLeft > 0 is immediately false. The loop body is never executed, not even once. The program jumps right over it and prints "Sold out!". This is a key feature of while loops: they are "pre-test" loops, meaning they check the condition before running.

The Dreaded Infinite Loop

Why does this happen? Almost always, it's because you forgot the update step.

// DANGER: INFINITE LOOP
int i = 0;

while (i < 5) {
  System.out.println("This is the song that never ends...");
  // Whoops! We forgot to change the value of i.
  // i will always be 0, and 0 is always less than 5.
}

This program will print "This is the song that never ends..." forever (or until you force the program to stop). The value of i never changes, so the condition i < 5 is never broken. Always make sure something inside your loop is working towards making the condition false.

Off-by-One Errors

Another classic pitfall. An "off-by-one" error is when your loop runs one time too many, or one time too few. This usually comes down to using < versus <= or choosing the wrong starting value.

Let's say you want to print the numbers 1 through 5.

// Correct way
int num = 1;
while (num <= 5) {
  System.out.println(num);
  num++;
}
// Prints: 1, 2, 3, 4, 5

// Common off-by-one mistake
int num = 1;
while (num < 5) { // Using < instead of <=
  System.out.println(num);
  num++;
}
// Prints: 1, 2, 3, 4 (Oops, missed 5!)

My best advice: When you write a loop, manually trace the first and last iterations.

• First iteration
  Does it start with the right value?
• Last iteration
  What is the last value that makes the condition true? What happens on that iteration?
• After the last
  What is the first value that makes the condition false? Does that correctly stop the loop?

Getting comfortable with while loops is about getting comfortable with this process of initialization, condition checking, and updating. Master these three parts, and you'll be able to tackle any repetitive task the AP exam throws at you.

Let's walk through a couple of problems to see how while loops work in practice.

Ready to try on your own? Remember to think about the three key parts: initialization, condition, and update.

Problem 1: The Doubler Write a program that starts with a number, n = 1. Using a while loop, keep doubling n (i.e., n = n * 2) and printing its value. The loop should stop once n is greater than 100. What is the first value of n that is printed that is greater than 100?

Hint: Your loop condition should probably be while (n <= 100). What happens in each iteration?

Problem 2: Password Checker A user needs to enter a password that is at least 8 characters long. Write a program that uses a Scanner to ask the user for a password. Use a while loop to keep asking for a password until the one they enter is 8 or more characters long.

Hint: You can get the length of a String s with s.length(). Your loop should continue while the length is less than 8.