Java for Loop

The for loop executes a block of code a specific number of times. When you know the iteration count upfront — the size of an array, the number of items to process, a fixed retry count — the for loop is the correct choice. It keeps the initialization, condition, and update all in one line, making the loop's intent immediately visible.

What separates solid for loop usage from beginner mistakes is understanding the three-part header and the precise moment each part executes. That timing is what causes off-by-one errors, infinite loops, and unexpected variable scope — all of which appear regularly in code reviews.

What Is the Java for Loop?

The for loop is a control flow statement that repeats a block of code while a condition is true, incrementing or decrementing a counter variable on each pass. The three parts of the loop header — initialization, condition, and update — are all declared in one line, which is the clearest signal to any developer reading the code that this loop runs for a known, bounded number of iterations.

Java provides three forms of the for loop:

• ›Basic for loop — when you need the index or a precise iteration count
• ›Enhanced for loop (for-each) — when you need each element but not the index
• ›Infinite for loop — when the loop's exit is controlled by internal logic, not a counter

Syntax

Basic for Loop

The three parts in the header:

1. ›Initialization — runs once before the first iteration
2. ›Condition — checked before each iteration; loop stops when false
3. ›Update — runs after each iteration, before the condition is re-checked

Enhanced for Loop (for-each)

The enhanced for loop, introduced in Java 5, iterates over arrays and any class that implements Iterable. It has no index variable and does not expose the current position — which makes it cleaner when you only need the values.

Infinite for Loop

All three parts are optional. Omitting the condition makes it permanently true. This pattern appears in server polling loops, retry mechanisms, and event processing systems where the exit condition is determined by runtime state, not a counter.

Beginner Examples

Basic for Loop — Iterating a Known Count

This shows the most common use case: processing a fixed range of values.

Output:
Order #1 processed. Value: Rs. 120.0
Order #2 processed. Value: Rs. 240.0
Order #3 processed. Value: Rs. 360.0
Order #4 processed. Value: Rs. 480.0
Order #5 processed. Value: Rs. 600.0
Batch complete. Total revenue: Rs. 1800.0

The loop variable index is declared inside the for header — it exists only within the loop block and the header itself. Once the loop exits, index is gone. This scoping is intentional: it prevents the loop counter from accidentally being used outside the loop where its value is no longer meaningful.

Enhanced for Loop — Iterating a Collection

When you need every element but do not need to track position, the enhanced form is cleaner and less error-prone than the basic form.

Output:
Product: Laptop | Tax category: 18.0%
Product: Mouse | Tax category: 18.0%
Product: Keyboard | Tax category: 18.0%
Product: Monitor | Tax category: 18.0%
Product: Webcam | Tax category: 18.0%

The enhanced for loop cannot be used when you need to modify the list while iterating, remove elements, or access adjacent elements by index. For any of those requirements, the basic for with explicit indexing is necessary.

Reverse Iteration

The for loop is equally natural for iterating backwards — common in search algorithms, undo stacks, and display logic.

Output:
Leaderboard (highest to lowest rank):
Rank 1: Deepa Reddy
Rank 2: Vikram Singh
Rank 3: Ananya Nair
Rank 4: Rahul Verma
Rank 5: Priya Sharma

Starting at topSellers.length - 1 instead of topSellers.length is the correct initialization for a zero-indexed array. Starting at length without subtracting 1 would cause an ArrayIndexOutOfBoundsException on the very first access — one of the most common off-by-one mistakes in Java.

How the Java for Loop Works Internally

Execution Sequence

Every iteration of a for loop follows a precise four-step sequence. Understanding this order is what prevents timing-related bugs.

                   Start
                     |
              Initialization
           (runs exactly once)
                     |
              +-----------+
              |           |
         Condition     Condition
          is true      is false
              |           |
        Execute body    Exit loop
              |
            Update
        (runs after body)
              |
        Re-check condition

The initialization runs once. The condition is checked before each iteration — including the first. The update runs after the body — the body executes first, then the update, then the condition is re-checked. This sequence matters when the update expression has side effects.

The Loop Variable Lives in Header Scope

The variable declared in the for header has a scope that includes the header itself and the loop body. It does not exist before the for statement or after it exits.

This scope design prevents a common class of bugs where a loop variable is accidentally read after the loop has run, when its value is meaningless.

Enhanced for Loop — Internal Iterator

The enhanced for loop is syntactic sugar. For any class implementing Iterable, the compiler transforms it into an Iterator-based loop. For arrays, the compiler transforms it into a basic indexed for loop internally. You never interact with the iterator directly, but knowing it exists explains why removing elements from a List inside an enhanced for loop throws a ConcurrentModificationException.

Real-World Example — Bulk Report Generator for an Ed-Tech Platform

The Business Problem

You are building the performance report generation service for an Indian ed-tech company — similar to what Vedantu or Physics Wallah runs for its batch report system. At the end of each monthly assessment cycle, the system must iterate through all student records in a batch, calculate their performance tier based on their score, and generate a formatted report line for each.

The report covers a known, fixed set of students — the batch size is determined before the loop starts. The for loop is the natural fit: bounded, index-accessible, and clean when the count is known at runtime.

Implementation

Output:
=== Monthly Assessment Report ===
Batch: JEE-2024-A
Total Students: 5
-----------------------------------
1. Arjun Mehta        | Score:  92 | Result: Distinction
2. Priya Iyer         | Score:  78 | Result: Pass
3. Rahul Singh        | Score:  55 | Result: Pass
4. Sneha Kapoor       | Score:  88 | Result: Distinction
5. Karan Patel        | Score:  41 | Result: Fail
-----------------------------------
Distinction: 2 | Pass: 2 | Fail: 1

The basic for loop with explicit indexing is used here — not the enhanced form — because the report number studentIndex + 1 is needed to label each line. The enhanced for would clean up the body slightly but would lose access to the sequential position number.

The thresholds are in ReportConfig as constants. When the institution changes the distinction cutoff from 85 to 90, only one line in one file changes. A mistake that appears often in fresher pull requests is hardcoding values like 85 and 50 directly inside loop bodies — those values then appear in multiple places and require scattered edits when requirements change.

Best Practices

Use the enhanced for loop when you do not need the index

The enhanced form is shorter, removes index management entirely, and eliminates the off-by-one class of bugs. Default to it when iterating collections and arrays unless the position genuinely matters to the logic.

Declare the loop variable inside the for header

Declaring the loop variable before the for statement unnecessarily widens its scope and leaves it accessible after the loop exits with a value that no longer means anything useful. IntelliJ IDEA and SonarQube both flag this as a code quality issue.

Keep the loop body focused on one responsibility

When a loop body grows beyond eight to ten lines, consider extracting it into a method. A loop that iterates students, calculates grades, formats output, and updates a database in a single body is doing too much. Extraction makes each concern testable independently.

Avoid modifying the collection inside an enhanced for loop

Removing or adding elements to a List while iterating it with the enhanced for throws ConcurrentModificationException. If modification during iteration is required, use an explicit Iterator with iterator.remove(), or iterate a copy while modifying the original.

Common Mistakes

Mistake 1 — Off-by-One Error in the Loop Condition

Off-by-one errors are the most common bug in basic for loops. The boundary condition — < versus <= — determines whether the last element is processed or skipped.

Output:
--- Using < scores.length (correct) ---
Score at index 0: 88
Score at index 1: 72
Score at index 2: 95
Score at index 3: 61
Score at index 4: 79

--- Using <= scores.length (causes ArrayIndexOutOfBoundsException) ---
Score at index 0: 88
Score at index 1: 72
Score at index 2: 95
Score at index 3: 61
Score at index 4: 79
Exception at index 5: Index 5 out of bounds for length 5

Java arrays are zero-indexed. The valid index range for an array of length 5 is 0 through 4. Using <= scores.length attempts to access index 5, which does not exist. The rule is always < array.length for forward iteration over a zero-indexed array.

Mistake 2 — Infinite Loop from Wrong Update Expression

Incrementing limit instead of counter means the condition counter < limit is always true — both sides grow but counter stays at 0 while limit increases without bound. During code reviews, three-part for headers where all three parts reference the same variable are flagged immediately.

Mistake 3 — Modifying the Loop Variable Inside the Body

Output:
i = 0
i = 2
i = 4

The loop only printed three values instead of five because i was incremented twice per iteration — once in the body and once in the update expression. Mutating the loop counter inside the body is consistently flagged in code reviews. If a step size other than 1 is needed, express it in the update expression: i += 2.

Mistake 4 — Using Enhanced for Loop When Modification Is Needed

Output:
ConcurrentModificationException: cannot modify list during iteration.

The correct approach for removing elements during iteration is to use Iterator with iterator.remove(), or to collect the elements to remove and delete them after the loop completes.

Interview Questions

Q1. What are the three parts of the Java for loop header and when does each execute?

The three parts are initialization, condition, and update. Initialization runs exactly once before the first iteration. The condition is checked before every iteration — if it is false on the first check, the loop body never runs. The update runs after each iteration, before the condition is re-evaluated. This ordering means the body executes before the update expression on each pass, which matters when the update has side effects.

Q2. What is the difference between a basic for loop and an enhanced for loop in Java?

The basic for loop uses an explicit index counter and can iterate in any direction, access elements by position, and modify the collection if using manual index management. The enhanced for loop iterates over every element in a collection or array without exposing an index, is simpler to write, and eliminates off-by-one errors from boundary conditions. The enhanced form cannot be used when you need the current position, need to skip elements, or need to modify the collection during iteration.

Q3. What causes a ConcurrentModificationException in a Java for-each loop?

The enhanced for loop uses an Iterator internally. Most Java collection implementations track a modification count. If the collection is modified directly — by calling add() or remove() on it — while the iterator is active, the iterator detects the change and throws ConcurrentModificationException as a safety mechanism to prevent inconsistent iteration state. The fix is to use Iterator.remove() for safe removal during iteration, or to collect items to modify and apply the changes after the loop completes.

Q4. How does the scope of a variable declared in the for loop header differ from one declared outside it?

A variable declared inside the for header exists only within the header and the loop body. Once the loop exits, that variable is no longer accessible. A variable declared before the for statement exists in the enclosing scope and is still accessible after the loop. Declaring loop counters inside the header is the preferred practice because it prevents the counter from being accidentally read or modified outside the loop where its value is undefined.

Q5. What is the for-each loop internally compiled to in Java?

For classes that implement Iterable, the enhanced for loop is compiled into an iterator-based loop — iterator.hasNext() controls the loop condition and iterator.next() retrieves each element. For arrays, it is compiled into a basic indexed for loop with an index starting at 0 and going to array.length - 1. The JVM never sees for-each directly; it sees the expanded form. This explains why ConcurrentModificationException is possible — the underlying iterator detects external modification.

Q6. When would you choose a while loop over a for loop in Java?

Use a for loop when the iteration count or the starting and ending bounds are known before the loop begins — iterating an array, processing a fixed batch size, or running a known number of retries. Use a while loop when the termination condition depends on runtime state that may change unpredictably — reading lines from a file until end-of-file, waiting for a network response, or polling a queue until it is empty. The general rule: for when you know the count, while when you do not.

FAQs

What is the for loop used for in Java?

The for loop repeats a block of code a specific number of times. Use it when the iteration count is known before the loop starts — processing all items in an array, running a fixed number of retries, or iterating through a list from start to finish. When the count is unknown and depends on runtime conditions, a while loop is more appropriate.

What is the enhanced for loop in Java?

The enhanced for loop, also called the for-each loop, iterates over every element in an array or collection without requiring an explicit index counter. Introduced in Java 5, it is simpler and less error-prone than the basic form when you only need the values and not the positions. It cannot modify the collection during iteration and does not expose the current index.

What happens if the for loop condition is false from the start?

The loop body never executes. The condition is checked before the first iteration — if it is already false, execution continues at the statement after the closing brace of the loop. A loop that never runs is valid Java and produces no error.

Can you have multiple variables in a for loop header in Java?

Yes. You can declare and initialize multiple variables of the same type in the initialization, and include multiple update expressions separated by commas. For example: for (int i = 0, j = 10; i < j; i++, j--). Variables of different types cannot be declared together in the initialization section.

How do you exit a for loop early in Java?

Use break to exit the loop immediately, regardless of whether the condition is still true. Use return inside a method to exit the method entirely, which also terminates the loop. Use continue to skip the rest of the current iteration and immediately move to the update expression. All three are valid and each serves a distinct use case.

What is an infinite for loop in Java?

An infinite for loop is written as for (;;), omitting all three header parts. The condition defaults to true and the loop runs indefinitely. Infinite loops are used in server polling systems, retry mechanisms, and event loops where the exit condition is determined by runtime logic inside the body using break or return.

Can you nest for loops in Java?

Yes. A for loop can contain another for loop in its body. Nested loops are used for two-dimensional array traversal, matrix operations, and generating combinations. The inner loop completes all its iterations for every single iteration of the outer loop. Be aware that nested loops multiply the iteration count — two loops of size N each produce N*N total iterations.

Summary

The for loop is the right choice when the iteration count is known before the loop starts. The three-part header — initialization, condition, update — runs in a precise sequence that determines exactly when each part executes, and understanding that timing is what prevents off-by-one errors and infinite loops.

The enhanced for loop removes index management entirely and is the cleaner choice whenever element position is not needed. When iteration requires modification, or when you need adjacent elements, the basic indexed form gives you that control.

For interviews, know the execution order of the three header parts, be able to explain what causes ConcurrentModificationException in a for-each loop, and be ready to compare for versus while with a concrete decision criterion. Those three points cover the depth that both service-based recall questions and product-based depth questions test on this topic.

What to Read Next