Java for Loop: Syntax, Execution Flow, Variations, and Examples

A for loop has exactly three parts in its header, separated by semicolons.

for (initialisation;
condition;
update) {
    // body runs only while the condition is true
}

That is the whole shape. Here it is with real values.

final int LAST = 5;
for (int i = 1;
i <= LAST;
i++) {
    System.out.println("Round " + i);
}

Read it out loud in three parts: start i at 1, keep going while i is at most 5, and after each round add 1 to i. Once you can say a for loop as a sentence like that, you can read any for loop you meet.

This is the part that matters most, so here it is as a numbered flow. Notice that initialisation appears once and the other two steps repeat.

1. Initialisation runs exactly once. The counter is created and given its first value before the loop body is ever reached.
2. The condition is tested. If it is false, the loop ends right here and the body never runs. Not once.
3. If true, the body runs. Every statement inside the braces executes from top to bottom.
4. The update expression runs. This happens after the body completes, every single time.
5. Control returns to the condition, not the initialisation. This is the detail people get wrong most often.

Step 5 is the one to remember. Because control goes back to the condition rather than the start, a loop can produce zero iterations. If the condition is false on the very first test, the body never executes even once. That is exactly the difference between a for loop and a do...while, where the body always runs at least once.

Most loops count upward, but a for loop is not limited to that. The direction is entirely up to how you write the condition and the update.

final int HIGHEST = 5;
// Counting up
for (int i = 1;
i <= HIGHEST;
i++) {
    System.out.println(i);
}// Counting down: the condition is reversed and the step is negative
for (int i = HIGHEST;
i >= 1;
i--) {
    System.out.println(i);
}// Counting by twos: the update just adds more
final int EVEN_LIMIT = 10;
final int STEP = 2;
for (int i = 0;
i <= EVEN_LIMIT;
i += STEP) {
    System.out.println(i);
}

Notice that counting down reverses both the condition and the step. Writing i-- while still testing i <= 5 is a genuine infinite loop, because the counter moves away from the bound and never reaches it. Whenever you change the direction, change the condition to match.

The most common beginner use of a for loop is accumulating something over a range. Here it is with the running total printed at each step, which is the best way to see what the loop is actually doing.

final int LIMIT = 5;
int sum = 0;
for (int i = 1;
i <= LIMIT;
i++) {
    sum = sum + i;
    System.out.println("Added " + i + ", running total is " + sum);
}

The output is 1, 3, 6, 10, 15. Tracing it by hand like this is the single best debugging habit for loops, because if you can predict the output on paper you will immediately see where the code disagrees with you.

Beyond simple counting, the for loop header has a few forms that come up regularly.

Two Counters Moving Toward Each Other

final int HIGH = 10;
int low = 1;
for (int i = low, j = HIGH;
i < j;
i++, j--) {
    System.out.println("i is " + i + " and j is " + j);
}

Multiple variables in the header are separated by commas, and multiple update expressions too. This is handy for palindrome checks, where you walk in from both ends at once.

An Intentional Infinite Loop

for (;
;
) {
    String line = readInput();
    if (line.equals("quit")) {
        break;
    } process(line);
}

With all three parts empty, the condition is treated as permanently true. This is a legitimate and common pattern for a menu or REPL loop that runs until the user explicitly quits. The break becomes the only exit, so make sure one is always reachable.

Looping Over an Array by Index

String[] names = {
    "Ada", "Linus", "Grace"
};
for (int i = 0;
i < names.length;
i++) {
    System.out.println(i + ": " + names[i]);
}

Note the use of names.length rather than a hard-coded number, so the loop keeps working if the array grows. If you do not need the index, prefer the for-each loop, which cannot have an off-by-one error. We compare the two on our looping overview page and cover the details on the enhanced for loop page.

Where you declare the loop variable changes where it can be used, and the recommended form keeps it inside the loop.

// RECOMMENDED: i exists only inside this loop
for (int i = 0;
i < 3;
i++) {
    System.out.println(i);
}// System.out.println(i);   // compile error, i is out of scope here
// AVOID: i leaks into the rest of the method
int j;
for (j = 0;
j < 3;
j++) {
    System.out.println(j);
}System.out.println(j);
// compiles, and is almost never what you meant

Declaring the counter in the header is better for a practical reason beyond tidiness. If you declare it outside, the variable survives after the loop holding its final value, and you can accidentally reuse it later in a way that produces a subtly wrong result. Scope it to the loop and the compiler stops you making that mistake.

The most common loop bug in all of programming is being wrong by exactly one. It comes down to whether your condition uses <= or <.

The first two are the same underlying mistake seen from two sides, and both produce the most alarming symptom a beginner can hit, which is a program that appears to hang with no error at all. If your program freezes, check the update expression first.

For escaping a running loop, see our break statement page and continue statement page. If you need loops inside loops, the nested loops page covers that in detail, and the while loop page covers the case where you do not know the count in advance.

A for loop is not always the right tool, and recognising that saves you from forcing a square peg into a round hole.

• You do not know the count in advance. Use a while loop, because a for loop with a made-up bound is just a while loop with extra steps.
• The body must run at least once. Use a do-while loop, since a for loop may run zero times.
• You are traversing data and do not need the index. Use the for-each loop, which has no off-by-one error to make.
• You are transforming a collection. A stream often says what you want far more clearly than an index loop.

And one caution about performance, because it is a common misconception. Writing a tight index loop is not meaningfully faster than a for-each loop, and neither is meaningfully faster than a stream for a small collection. The JVM handles all of these efficiently. Choose the form that reads most clearly, because that is where the real gains are.

Frequently Asked Questions

What does for (;;) do?

It is an infinite loop. All three parts are optional, so with an empty condition Java treats the loop as permanently true and it runs until a break, a return, or an exception stops it. It is a legitimate pattern for a menu loop.

Can the parts of a for loop be left empty?

Yes, any of the three. You can keep only the condition, only the update, or none at all. This is what makes patterns like counting down with a manually managed counter possible, though a while loop is usually clearer for that.

Why is my for loop running forever?

Almost always because the update expression does not move the counter toward the condition, or because you reversed the direction without reversing the condition. Also check for a stray = where you meant ==.

Why does my loop run zero times?

Because the condition was already false on the very first test. A for loop checks the condition before the body, so if the starting value does not satisfy it, nothing runs. Use a do-while if you need one guaranteed pass.

Should I use <= or < with arrays?

Use < with .length, since valid array indices run from zero to length minus one. Using <= is the classic off-by-one that throws an exception on the last pass.

Can I declare the loop variable outside the loop?

You can, but it is not recommended. The variable then survives after the loop and can be misused later by accident. Declaring it in the header keeps its scope tight and lets the compiler catch mistakes.

Is a for loop faster than a while loop?

No, they compile to essentially the same thing. A for loop is preferred for readability, because the counter, the bound and the step sit together in one visible line instead of being split across the method.