2.7 While Loops

A while loop repeats a block of code as long as its Boolean condition stays true, checking that condition before every iteration, including the first. This makes while loops useful when you do not know in advance how many repetitions you need, like reading input until a stop value or looping until a target is reached. For AP Computer Science A, trace the loop condition, body, and update to avoid infinite loops and off-by-one errors.

How Do while Loops Work in Java?

A while loop checks a Boolean condition before each repetition. If the condition is true, the loop body runs and should update something that moves the loop toward stopping; if the condition is false before the first check, the body runs zero times.

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

Why This Matters for the AP Computer Science A Exam

Iteration is one of the three building blocks of algorithms, alongside sequencing and selection, so while loops show up constantly in AP Computer Science A. On the multiple-choice section, you will trace loops to find output or final variable values, and you will spot code that runs one time too many or too few. In free-response code writing, you often need to write iterative statements that repeat until a condition is met, sometimes combined with if statements to stop early.

A big part of working with while loops is describing the initial conditions a loop needs to run correctly. If a loop control variable starts at the wrong value, or the update is missing or pointed the wrong way, the loop either never runs, runs forever, or produces the wrong count. Being able to trace a loop carefully and explain why it behaves a certain way is exactly the kind of thinking the exam rewards.

Key Takeaways

• A while loop checks its Boolean condition before each iteration, so the body can run zero, one, or many times.
• If the condition is false at the start, the loop body never executes and the program moves on.
• An infinite loop happens when the condition always stays true, usually because the loop control variable never changes or changes in the wrong direction.
• Off-by-one errors come from loop bounds that are slightly off, making the loop run one time too many or one time too few.
• Loop control variables and accumulators must be initialized before the loop and updated inside the body.
• Tracing a loop line by line with sample values is the most reliable way to predict its behavior.

Core Concepts

What Iteration Means

Iteration is repetition in programming. Instead of copying the same code many times, you write it once and let the program repeat it as long as needed. Iteration changes the flow of control by repeating a segment of code zero or more times, as long as the Boolean expression controlling the loop stays true.

The while loop is the most basic form of iteration. It keeps running a block of code while 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). The condition is evaluated before each iteration, including the first one. When it is true, the body runs. When it becomes false, the loop ends and the program continues after it.

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

Because the condition is checked first, a loop whose condition starts out false never runs its body at all.

Loop Control Variables

Most while loops use a variable to control when the loop stops. This variable changes inside the body, eventually making the condition false. Think of it like a countdown: start with a number, do something, then change the number until it hits the stopping point.

</>Java
int count = 5;
while (count > 0) {
    System.out.println("Count: " + count);
    count--;  // This changes the condition each time
}

If you forget to update the control variable, the condition never becomes false and you get an infinite loop.

The Zero Iterations Case

Sometimes the condition is false right from the start, so the body never runs. That is normal and often exactly what you want.

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

Code Examples

Basic Counting Loop

</>Java
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");
    }
}

Sum Accumulator Pattern

</>Java
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

An accumulator is a variable that builds up a running total. Initialize it before the loop, then update it each pass through the body.

Counting Digits in an Integer

This is a standard pattern you should get comfortable with: pull apart an integer one digit at a time.

</>Java
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 the last digit
        count++;               // Count this digit
    }
    return count;
}

Each division by 10 removes one digit. The loop counts how many times you can do that before the number reaches 0.

Common Errors and Debugging

Infinite Loop

An infinite loop happens when the condition never becomes false, so the program repeats forever. An infinite loop occurs when the Boolean expression always evaluates to true.

A common cause is forgetting to update the loop control variable inside the body.

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

}

Fix it by making sure the body contains code that eventually makes the condition false.

</>Java
int count = 5;
while (count > 0) {
    System.out.println("Count: " + count);
    count--;  // This moves the loop toward stopping
}

If your program seems frozen, check for loop control variables that never change.

Off-by-One Error

An off-by-one error happens when the loop runs one time too many or one time too few. These are common and easy to miss.

</>Java
// 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)

Fix it by checking your loop bounds carefully and testing with small examples.

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

Tracing the loop by hand with small values is the fastest way to catch these.

Wrong Update Direction

If you update the control variable in the wrong direction, the condition never becomes false.

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

// countdown keeps getting bigger, never reaches 0

Make sure your update moves the variable toward the stopping condition.

How to Use This on the AP Computer Science A Exam

Code Tracing

When you trace a while loop, remember the condition is checked before every iteration, including the first. Work through it step by step and write down the variable values as they change each pass. Do not try to compute the final answer in your head, especially for accumulator loops where one missed update changes everything. Watch for loops whose condition is false at the start, since those run zero times.

Free Response

In free-response code writing, you will often write iterative statements that repeat until a condition is met. A reliable pattern:

• Initialize your loop control variable and any accumulator before the loop.
• Write a condition that becomes false at the right moment.
• Update the control variable inside the body so the loop makes progress.
• If you need to stop early, use an if statement inside the body to control when the loop ends.

Common Trap

Infinite loops and off-by-one errors show up often as wrong answers in multiple choice. When you scan answer choices, check whether the loop control variable changes and whether it changes in the right direction. For the bounds, plug in the starting and ending values to confirm the loop runs the exact number of times you expect.

Common Misconceptions

• "A while loop always runs at least once." Not true. The condition is checked before the first iteration, so if it starts false, the body never runs. The loop that always runs once is the do-while, which is outside the AP subset.
• "The condition is rechecked in the middle of the body." The condition is only checked between iterations, before each pass. Code in the body finishes running before the condition is evaluated again.
• "Any infinite loop is a syntax error the compiler catches." An infinite loop usually compiles fine. It is a logic problem that shows up only when the program runs and never stops.
• "Off-by-one errors mean the code crashes." Often the code runs without error but produces a count or result that is one off. That is what makes these bugs sneaky.
• "You must use a counter that goes up by one." A while loop condition can be anything that evaluates to a Boolean, like comparing a value to a target or checking a running total, not just a counter incrementing by one.

Related AP Computer Science A Guides

• 2.1 Algorithms with Selection and Repetition
• 2.2 Boolean Expressions
• 2.6 Equivalent Boolean Expressions
• 2.11 Nested Iteration
• 2.12 Informal Code Analysis
• 2.8 For Loops
• 2.10 Developing Algorithms Using Strings