Java for Loop Explained — Syntax, Examples and Common Mistakes

Almost every real program needs to repeat something. A banking app applies interest to thousands of accounts. A game redraws the screen 60 times per second. A search engine scores millions of web pages. Without a way to repeat code automatically, you'd have to copy and paste the same lines thousands of times — and then the first bug would require thousands of fixes. That's not programming, that's punishment.

The for loop solves this elegantly. It lets you write an action once and tell Java exactly how many times to run it. It also keeps a counter variable automatically, so you always know which repetition you're on. This makes it perfect for any situation where you know in advance how many times something needs to happen — like processing every item in a list, or printing a times table.

By the end of this article you'll understand every part of a for loop's syntax, be able to write one from scratch without looking anything up, know how to loop through arrays, nest one loop inside another, and spot the two mistakes that trip up nearly every beginner. You'll also walk away with the answers to the for loop questions that show up in junior Java interviews.

Anatomy of a Java for Loop — What Each Part Actually Does

A for loop has three parts crammed into one line, separated by semicolons. Each part has a specific job, and understanding each job separately makes the whole thing click.

The first part is the initializer. It runs exactly once — right before the loop starts. You use it to create and set your counter variable. Think of it as setting the odometer to zero before a road trip.

The second part is the condition. Java checks this before every single repetition. If it's true, the loop body runs. If it's false, the loop stops immediately and Java moves on. This is the gatekeeper.

The third part is the update. It runs after every repetition of the loop body — right before the condition is checked again. You use it to change your counter so the loop eventually ends.

That order matters: initializer → check condition → run body → update → check condition again → and so on. Miss any of those three parts and the loop either never starts, or never stops. Let's see all three in action with a concrete example.

public class BirthdayInvitations {
    public static void main(String[] args) {

        // We need to write 5 birthday invitations.
        // The for loop handles the counting for us.
        //
        // Part 1 — int invitationNumber = 1
        //   Creates a counter and starts it at 1.
        //   Runs ONCE before the loop begins.
        //
        // Part 2 — invitationNumber <= 5
        //   The gatekeeper. Checked before every repetition.
        //   When invitationNumber hits 6, this is false and the loop stops.
        //
        // Part 3 — invitationNumber++
        //   Adds 1 to our counter after each repetition.
        //   invitationNumber++ is shorthand for invitationNumber = invitationNumber + 1

        for (int invitationNumber = 1; invitationNumber <= 5; invitationNumber++) {
            System.out.println("Writing invitation #" + invitationNumber);
        }

        // This line runs AFTER the loop finishes — the loop does not affect it.
        System.out.println("All invitations written!");
    }
}

Looping Through an Array — The Most Common Real-World Use Case

The single most common use of a for loop in Java is walking through every element of an array. An array is just a numbered list of values — like a row of lockers, each with a number starting from 0.

That 'starting from 0' detail is critical. In Java, arrays are zero-indexed. The first element is at position 0, not 1. A 5-element array has positions 0, 1, 2, 3, 4. The last valid position is always the array's length minus one. This is exactly why most loops that iterate over arrays start their counter at 0 and use the condition i < array.length rather than i <= array.length — using <= would send your counter one slot past the end of the array and cause a crash.

The loop counter doubles as the index, which is the clever part. On the first pass i is 0 so you read element 0. On the second pass i is 1 so you read element 1. The loop and the array stay in perfect sync automatically.

Let's build something real — calculating the total score from a student's test results.

public class StudentScoreCalculator {
    public static void main(String[] args) {

        // An array of five test scores for a student.
        // Array positions: [0]=85  [1]=92  [2]=78  [3]=95  [4]=88
        int[] testScores = {85, 92, 78, 95, 88};

        int totalScore = 0; // We'll add each score into this.

        // testScores.length is 5, so the loop runs for i = 0, 1, 2, 3, 4
        // Notice: i < testScores.length   (NOT <=)   — this is intentional.
        // If we used <= 5, we'd try to read testScores[5] which doesn't exist.
        for (int i = 0; i < testScores.length; i++) {
            System.out.println("Score " + (i + 1) + ": " + testScores[i]);
            totalScore = totalScore + testScores[i]; // accumulate the running total
        }

        // Calculate the average — we know there are exactly 5 scores
        double averageScore = (double) totalScore / testScores.length;

        System.out.println("----------------------------");
        System.out.println("Total Score  : " + totalScore);
        System.out.printf("Average Score: %.1f%n", averageScore);
    }
}

Nested for Loops — Loops Inside Loops (And When You Actually Need Them)

Sometimes one dimension of repetition isn't enough. Imagine printing a multiplication table — you need every number from 1 to 10 multiplied by every other number from 1 to 10. That's a grid. Grids have rows and columns, and that's exactly where nested loops shine.

A nested loop is simply a loop inside another loop. The outer loop controls rows. The inner loop controls columns. For every single iteration of the outer loop, the inner loop runs all the way through its full cycle. So if the outer loop runs 3 times and the inner loop runs 4 times, the loop body executes 3 × 4 = 12 times total.

The variable names matter here. Use row and col, or i and j — but never use i for both loops. Each loop needs its own independent counter variable or they'll overwrite each other and produce nonsense.

Nested loops are also used in real-world code to compare every element in a list against every other element, to process 2D grids in games, and to validate matrix data in data science applications.

public class MultiplicationTable {
    public static void main(String[] args) {

        int tableSize = 5; // We'll print a 5x5 multiplication table

        System.out.println("--- 5x5 Multiplication Table ---");

        // OUTER LOOP: controls which row we're on (1 through 5)
        for (int row = 1; row <= tableSize; row++) {

            // INNER LOOP: controls which column we're on (1 through 5)
            // For every single value of 'row', this entire inner loop
            // runs from col=1 all the way to col=5.
            for (int col = 1; col <= tableSize; col++) {

                int product = row * col;

                // %4d means: print an integer, padded to 4 characters wide.
                // This keeps the columns aligned neatly.
                System.out.printf("%4d", product);
            }

            // After the inner loop finishes one full row, move to the next line.
            System.out.println();
        }
    }
}

Controlling Loop Flow with break and continue

Sometimes you need to exit a loop early, or skip one specific iteration without stopping the whole loop. Java gives you two keywords for this: break and continue.

break is the emergency exit. The moment Java hits break, it leaves the loop entirely — no more iterations, no going back. This is useful when you're searching for something and you've found it. There's no point checking the rest of the list once you've already got your answer.

continue is more subtle. It doesn't stop the loop — it just skips the rest of the current iteration and jumps straight to the update step, then rechecks the condition. Think of it as 'never mind this one, carry on to the next.' This is handy when you want to process most items but ignore a specific type.

Both keywords work in nested loops too, but they only affect the loop they're directly inside. To break out of an outer loop from inside an inner loop, Java supports labeled breaks — but that's an advanced topic for another day.

public class SecurityScanner {
    public static void main(String[] args) {

        // Simulating a list of usernames being scanned.
        // We want to:
        //   1. Skip any username that is blank (continue)
        //   2. Stop scanning immediately if we find a banned user (break)
        String[] usernames = {"alice", "bob", "", "charlie", "BANNED_USER", "diana"};

        System.out.println("Starting security scan...");

        for (int i = 0; i < usernames.length; i++) {

            // If the username is blank, skip it — nothing to check.
            // 'continue' jumps straight to i++ then rechecks the condition.
            if (usernames[i].isEmpty()) {
                System.out.println("Slot " + i + ": empty — skipping.");
                continue;
            }

            // If we find the banned user, raise the alarm and stop scanning.
            // 'break' exits the for loop immediately.
            if (usernames[i].equals("BANNED_USER")) {
                System.out.println("ALERT: Banned user detected at slot " + i + "! Halting scan.");
                break;
            }

            // This line only runs if neither condition above triggered.
            System.out.println("Slot " + i + ": '" + usernames[i] + "' cleared.");
        }

        System.out.println("Scan complete.");
    }
}

Frequently Asked Questions