2.7 While Loops

While loops are the foundation of iteration in Java, allowing you to repeat code as long as a condition remains true. Unlike if statements that execute once, while loops can execute their code block zero, one, or many times based on a boolean expression. This makes them perfect for situations where you don't know exactly how many repetitions you'll need.

The power of while loops comes from their simplicity and flexibility. You provide a condition, and as long as that condition evaluates to true, the loop body executes. This pattern appears everywhere - from processing user input to searching through data to performing calculations until you reach a target value.

• Major concepts: Iteration basics, loop control with boolean expressions, infinite loops, off-by-one errors
• Why this matters for AP: Foundation for all iteration topics, appears in every FRQ type involving repetition
• Common pitfalls: Infinite loops, off-by-one errors, forgetting to update loop control variables
• Key vocabulary: Iteration, loop body, boolean expression, infinite loop, loop control variable
• Prereqs: Boolean expressions, if statements, understanding of program flow control

Key Concepts

What Iteration Really Means

Iteration is just a fancy word for repetition in programming. Instead of copying and pasting the same code multiple times, you write it once and let the computer repeat it as many times as needed.

The while loop is the most basic form of iteration. It keeps executing a block of code as long as a condition remains true.

How while Loops Work

A while loop has two main parts: the boolean expression (the condition) and the loop body (the code that repeats). Before each iteration, the program checks if the condition is true. If it is, the loop body executes. If not, the program skips past the entire loop.

while (condition) {
    // Code that repeats
    // This is the loop body
}

The key insight is that the condition is checked before each iteration, including the very first one. If the condition starts out false, the loop body never executes at all.

Loop Control Variables

Most while loops use a variable to control when the loop should stop. This variable changes inside the loop body, eventually making the condition false.

Think of it like a countdown timer. You start with a number, do something, then decrease the number. When it reaches zero, you stop.

int count = 5;
while (count > 0) {
    System.out.println("Count: " + count);
    count--;  // This is crucial - it changes the condition

}

The Zero Iterations Case

This was something that confused me initially. Sometimes the loop condition is false right from the start, so the loop body never executes. That's totally normal and often exactly what you want.

int number = 10;
while (number < 5) {
    System.out.println("This never prints");
}
System.out.println("Program continues here");

Code Examples

Basic Counting Loop

public class CountingExample {
    public static void main(String[] args) {
        // Count from 1 to 5
        int i = 1;
        while (i <= 5) {
            System.out.println("Iteration " + i);
            i++;  // Don't forget this!
        }
        System.out.println("Loop finished");
    }
}

User Input Processing

import java.util.Scanner;

public class MenuExample {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String choice = "";

        // Keep showing menu until user chooses to quit
        while (!choice.equals("quit")) {
            System.out.println("Enter 'hello', 'goodbye', or 'quit':");
            choice = input.nextLine();

            if (choice.equals("hello")) {
                System.out.println("Hi there!");
            } else if (choice.equals("goodbye")) {
                System.out.println("See you later!");
            } else if (!choice.equals("quit")) {
                System.out.println("I don't understand that command.");
            }
        }
        System.out.println("Thanks for using the program!");
    }
}

Sum Accumulator Pattern

public class SumExample {
    public static void main(String[] args) {
        // Calculate sum of numbers 1 through 10
        int sum = 0;        // Accumulator starts at 0
        int number = 1;     // Loop control variable

        while (number <= 10) {
            sum += number;   // Add current number to sum
            number++;        // Move to next number
        }

        System.out.println("Sum of 1 to 10 is: " + sum);
    }
}
// Output: Sum of 1 to 10 is: 55

Search Until Found

import java.util.Scanner;

public class GuessExample {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int secret = 7;
        int guess = -1;  // Initialize to something that won't match

        System.out.println("I'm thinking of a number between 1 and 10");
        while (guess != secret) {
            System.out.print("What's your guess? ");
            guess = input.nextInt();

            if (guess < secret) {
                System.out.println("Too low!");
            } else if (guess > secret) {
                System.out.println("Too high!");
            }
        }
        System.out.println("You got it! The number was " + secret);
    }
}

Common Errors and Debugging

Infinite Loop Error

An infinite loop happens when the loop condition never becomes false. The program gets stuck repeating forever.

Common cause: Forgetting to update the loop control variable inside the loop body.

Example scenario:

int count = 5;
while (count > 0) {
    System.out.println("Count: " + count);
    // Forgot to decrease count - infinite loop!

}

How to fix: Make sure the loop body contains code that eventually makes the condition false.

int count = 5;
while (count > 0) {
    System.out.println("Count: " + count);
    count--;  // This is essential!
}

Debugging tip: If your program seems frozen, check if you have an infinite loop. Look for loop control variables that never change.

Off-by-One Error

This happens when your loop runs one time too many or one time too few. It's super common and can be tricky to spot.

Common cause: Using wrong comparison operators or starting/ending values.

Example scenario:

// Want to print numbers 1 through 5
int i = 1;
while (i < 5) {  // Bug: should be i <= 5
    System.out.println(i);
    i++;
}
// Only prints 1, 2, 3, 4 (missing 5)

How to fix: Carefully check your loop bounds and test with simple examples.

int i = 1;
while (i <= 5) {  // Correct: includes 5
    System.out.println(i);
    i++;
}

Debugging tip: Trace through your loop manually with pencil and paper for small values.

Wrong Update Direction

Sometimes you update the loop control variable in the wrong direction, creating an infinite loop.

Common cause: Using ++ when you should use -- or vice versa.

Example scenario:

int countdown = 10;
while (countdown > 0) {
    System.out.println(countdown);
    countdown++;  // Bug: should be countdown--
}

// countdown keeps getting bigger, never reaches 0

How to fix: Make sure your update moves the variable toward the stopping condition.

Practice Problems

Problem 1: Password Validator

Write a program that keeps asking for a password until the user enters "secret123":

import java.util.Scanner;

public class PasswordValidator {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        // Your code here
    }
}

Solution:

import java.util.Scanner;

public class PasswordValidator {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String password = "";

        while (!password.equals("secret123")) {
            System.out.print("Enter password: ");
            password = input.nextLine();

            if (!password.equals("secret123")) {
                System.out.println("Incorrect password. Try again.");
            }
        }
        System.out.println("Access granted!");
    }
}

Key insight: Initialize the password to something that won't match, so the loop runs at least once.

Problem 2: Digit Counter

Write a method that counts how many digits are in a positive integer:

public static int countDigits(int number) {
    // Your code here - use a while loop

}

Hint: You can remove the last digit with number / 10 and keep doing this until the number becomes 0.

Solution:

public static int countDigits(int number) {
    if (number == 0) {
        return 1;  // Special case: 0 has 1 digit
    }

    int count = 0;
    while (number > 0) {
        number = number / 10;  // Remove last digit
        count++;               // Count this digit
    }
    return count;
}

Explanation: Each division by 10 removes one digit. We count how many times we can do this before the number becomes 0.

Problem 3: Sum Until Negative

Write a program that keeps asking for numbers and adds them up, stopping when the user enters a negative number:

Solution:

import java.util.Scanner;

public class SumUntilNegative {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int sum = 0;
        int number = 0;  // Initialize to non-negative

        while (number >= 0) {
            System.out.print("Enter a number (negative to stop): ");
            number = input.nextInt();

            if (number >= 0) {  // Only add non-negative numbers
                sum += number;
            }
        }
        System.out.println("Total sum: " + sum);
    }
}

Key insight: Check the condition inside the loop to avoid adding the negative number to the sum.

AP Exam Connections

While loops are fundamental to many AP Computer Science A topics and appear across all FRQ types.

Multiple Choice Patterns

You'll see questions about tracing through while loops to determine output or final variable values. Common patterns include counting loops, accumulator patterns, and loops that process until a condition is met. Pay attention to off-by-one errors in answer choices.

FRQ Applications

FRQ 1 (Methods and Control Structures): While loops often appear in methods that need to repeat until a specific condition is met, like input validation or iterative calculations.

FRQ 2 (Class Design): Methods in classes might use while loops to process data or search through object attributes until finding what they need.

FRQ 3 (Array/ArrayList): While loops can traverse arrays when you need more control than a for loop provides, especially when the stopping condition isn't just reaching the end.

FRQ 4 (2D Array): Sometimes while loops help process 2D arrays when the iteration pattern doesn't fit neatly into nested for loops.

Quick Test-Taking Tips

Always trace through while loops carefully, paying attention to when the condition is checked. Remember that the condition is evaluated before each iteration, including the first one. When you see loop control variables, follow how they change to determine when the loop stops.

If a question asks about loop output, work through each iteration step by step. Don't try to calculate the result mentally - write out the variable values as they change.

Watch for infinite loops in code - they're common wrong answers in multiple choice questions. Look for loop control variables that never change or change in the wrong direction.