ReviseAlgo Logo

Control Flow

for Loop

Understand the standard three-part for loop, index control variables, loop condition bounds, and loop execution lifecycle.

Interview: Tests loop initialization expressions, multiple loop variables, execution order, and infinite loop cases.

Last Updated: June 13, 2026 • 10 min read

The standard for loop is a definite iteration block in Java. It consolidates loop initialization, condition testing, and iteration updates into a single line. This loop is ideal when the number of execution passes is known beforehand or bounded by sequential array indexes.

Core Idea

Standard for loops initialize variables, check terminating bounds, execute code bodies, and increment counters in a cyclic sequence.

Why It Matters

Loop indexes declared within the loop initialization header have a scope restricted to the loop itself, preventing pointer leakage.

Interview Lens

Expect questions targeting multi-variable headers, loop execution orders, off-by-one check limits, and infinite loops.

Lifecycle and Execution Order

A standard for loop consists of three expressions in its header: for (initialization; condition; update). The execution sequence is:

  1. Initialization: Runs exactly once when entering the loop block. It is typically used to declare and initialize loop control variables.
  2. Condition Evaluation: Checked prior to every iteration. If true, the loop body runs. If false, control exits the loop.
  3. Loop Body: Executes the statements contained within the braces.
  4. Update Expression: Executes immediately after the loop body completes, before the condition is re-evaluated.

Multi-Variable Loops

You can declare and manage multiple variables inside the for loop initialization segment, provided they share the exact same base data type. They can be separated by commas. 

// Valid: both are integers
for (int i = 0, j = 10; i < j; i++, j--) {
    System.out.println("i=" + i + ", j=" + j);
}

// INVALID: different types (compilation error)
// for (int i = 0, double d = 0.5; ... )

Common Pitfalls

  • Off-by-One Errors: Using i <= array.length instead of i < array.length, triggering runtime ArrayIndexOutOfBoundsExceptions.
  • Accidentally Adding Semicolon: Writing for (int i=0; i<10; i++); { ... } treats the semicolon as an empty loop body. The braces execute exactly once after the empty loop terminates.
  • Shadowing or Re-Declaring: Declaring a loop control variable in the header that was already declared in the local outer scope, causing variable duplication errors.

Best Practices

  • Always declare control index variables inside the loop header to limit their scope and encourage prompt garbage collection.
  • Avoid modifying the loop control variable manually inside the loop body, as this makes logic debugging highly confusing.
  • Prefer enhanced-for loops or Stream APIs when iterating over collections unless index access is explicitly required.

Interview-Relevant Information

Q1: What represents an infinite loop using a for statement, and what does it compile to?
Answer: Writing for (;;) { } represents an infinite loop. The Java compiler parses this empty header structure and compiles it directly into a simple, unconditional jump bytecode instruction (e.g., goto), skipping condition evaluations entirely.

Q2: Can we skip expressions in a for header?
Answer: Yes. All three parts of the loop header are optional. However, the separating semicolons must remain, e.g., for (; x < 100; ) is valid if the initialization was done previously and updates occur inside the loop body.

Quick Checklist

Can you trace loop execution cycles, declare multiple variables in a single header, identify off-by-one errors, and compile empty loop statements? If yes, you understand for loops.

Use Cases

Iterating sequentially through array buffer indexes to perform inline math operations.

Structuring grid configurations using nested loop sequences.

Common Mistakes

Appending trailing semicolons to the loop header expression, leading to empty iterations.

Failing to restrict index counters to local loop header visibility, leaking variables into outer scopes.