For Loop in Java

Understanding the For Loop in Java

“Programs must be written for people to read, and only incidentally for machines to execute.” — Harold Abelson once said that, and it fits perfectly when talking about loops. A for loop in Java is one of those constructs that turns repetitive tasks into clean, readable logic. Instead of writing the same line ten times, you write it once — and let the loop handle the rest.

According to a 2024 developer survey, over 90% of Java developers rely on looping statements as part of their daily workflow. Whether you’re iterating through data, generating reports, or counting records, the for statement gives you predictable, structured control. It’s not just about repetition; it’s about precision — executing the right number of steps, at the right time, in the right order.

You’ll see how initialization, condition, and update work together to control iteration in Java. Each part has a clear role — start, check, move — and when combined, they create a cycle that’s efficient and easy to debug. Once you master it, you’ll stop writing long, clumsy code blocks and start crafting loops that do more with less.

In this lesson, we’ll trace, test, and even break a few loops to see what happens when logic goes wrong. You’ll write real examples, spot common errors, and learn how to fix them. By the end, you’ll be confident in using the for loop in Java to automate repetitive tasks — from counting numbers to generating patterns. Let’s get your first loop running!

Syntax and Structure of the For Loop

The for loop in Java is designed for situations where you already know how many times a task needs to run. It’s a structured, count-based loop that gives you full control over repetition — from where to start, when to stop, and how to move through each step.

Think of it as a compact counter that keeps everything in one line. The for statement brings together three important parts: initialization, condition, and update. Together, they define how your loop behaves from start to finish.

for (initialization; condition; update) {
    // code that repeats
}

Each part has a specific role:

• Initialization – sets up your loop counter. Runs once before the loop starts. Example: int i = 1;
• Condition – decides whether the loop continues or stops. Example: i <= 5;
• Update – changes the counter after every iteration. Example: i++;

When you combine these parts, the loop runs smoothly in sequence:

1. Initialization runs once before the loop starts.
2. The condition is checked before every cycle.
3. If the condition is true, the loop body runs.
4. After the body, the update changes the counter.
5. Then Java checks the condition again — and the process repeats.
6. When the condition becomes false, the loop stops.

In short, a for loop in Java helps you control repetition with precision. It’s the go-to tool for predictable, fixed-range tasks — whether you’re printing a list of numbers, processing user input, or iterating over arrays.

Why Use a For Loop?

The for loop in Java is your best choice when the number of repetitions is known in advance. It’s efficient, predictable, and keeps your code clean — especially in programs that depend on counters or fixed iterations.

You’ll often use a for statement when:

• You already know how many times a block of code should repeat.
• You need a simple counter that moves up or down.
• You want your loop logic in one place for better readability.
• You’re working with arrays or lists that have a fixed length.

Unlike the while loop, which checks the condition before each iteration without knowing the total count, the for loop provides complete structure — start point, end point, and step — all in one line.

Here’s a simple example that behaves just like a while loop:

int i = 0;
for (; i < 5; ) {
    System.out.println(i);
    i++;
}

This version keeps the loop flexible. Even if parts like initialization or update are missing, Java still recognises it as a valid for loop structure — as long as the semicolons remain in place.

Think About It

• Where does Java check the condition — before or after running the code?
• What happens if you forget to update the counter?
• Can a for loop count backward instead of forward?

These are small details, but mastering them helps prevent infinite loops and logic errors in your programs. Every iteration in Java becomes more reliable once you understand how the control flow works.

Example 1: Counting from 1 to 5

Let’s see the for loop in Java in action. In this example, you’ll use a loop counter to print numbers from 1 to 5. It’s one of the simplest and most common use cases when working with looping statements.

public class ForLoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Count: " + i);
        }
    }
}

Expected Output

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5

Step-by-Step Breakdown

Here’s what happens behind the scenes for each iteration:

1. Initialization: int i = 1; sets the starting value of the loop counter.
2. Condition: i <= 5; is checked before each loop. If true, the loop runs.
3. Body: System.out.println("Count: " + i); prints the current number.
4. Update: i++; increases i by 1 after every iteration.
5. Once the condition becomes false (when i is 6), the loop ends automatically.

Tracing the Loop

Key Takeaways

• The variable i serves as the loop counter.
• The loop runs five times — from 1 to 5.
• The condition i <= 5 ensures proper termination.
• Once the condition becomes false, Java exits the loop automatically.

Try This Yourself

• Change the starting value to 0 and observe how many times it loops.
• Modify the condition to i < 10 — what happens now?
• Replace i++ with i += 2 — what output do you get?

Write down your observations. The goal is to understand how small changes in the for statement affect the loop’s behaviour.

Example 2: Displaying Even Numbers

Not every loop needs to count by ones. Sometimes, you want to skip certain numbers — like printing only even values. The for loop in Java makes that easy with a small tweak to the update expression.

public class EvenNumbers {
    public static void main(String[] args) {
        for (int i = 2; i <= 10; i += 2) {
            System.out.println(i);
        }
    }
}

Expected Output

2
4
6
8
10

How This Code Works

1. Initialization: int i = 2; sets the loop to start at 2 — the first even number.
2. Condition: i <= 10; tells Java to continue looping while i is 10 or below.
3. Body: System.out.println(i); prints the current even number.
4. Update: i += 2; adds 2 to i each time, skipping odd numbers entirely.

Tracing the Loop

What You Can Learn Here

• The update part doesn’t always have to be i++;.
• You can control your loop’s step pattern — count by twos, fives, or any value.
• Changing the increment can simplify many real-world loops, like processing every second record in a dataset.

Try This Yourself

• Modify the code to print odd numbers from 1 to 9. Hint: start at 1 and use i += 2.
• Change the limit to 20. What happens to your output?
• Experiment with i -= 2 — what if you start at 10 instead?

Quick Reflection

• Why did we use i += 2 instead of i++?
• What happens if the condition is i < 10 instead of i <= 10?
• How can you make the loop print multiples of 3 instead?

Example 3: Countdown (Loop Decrementing)

So far, every for loop in Java we’ve written has counted upward — starting small and increasing with each iteration. But loops aren’t limited to moving forward. You can also make them count backward by adjusting the initialization, condition, and update.

public class Countdown {
    public static void main(String[] args) {
        for (int i = 10; i >= 1; i--) {
            System.out.println(i);
        }
        System.out.println("Blast off!");
    }
}

Expected Output

10
9
8
7
6
5
4
3
2
1
Blast off!

How This Code Works

1. Initialization: int i = 10; starts the loop at 10.
2. Condition: i >= 1; keeps the loop running while i is at least 1.
3. Body: System.out.println(i); prints the current value.
4. Update: i--; decreases i by 1 after each iteration.
5. When i becomes 0, the condition is false — and the loop ends with “Blast off!”.

Tracing the Loop

Key Points

• i-- decreases the loop counter each cycle.
• The condition i >= 1 ensures it stops exactly at 1.
• After the final iteration, the program continues to the next statement — System.out.println("Blast off!");.

Try This Yourself

• Change the starting number to 5 and end at 1 — what does the output look like?
• Replace i >= 1 with i > 0 — any difference?
• Add a message before the loop: System.out.println("Starting countdown...");

Challenge

Modify the code so it prints only even numbers during the countdown.

10
8
6
4
2
Blast off!

Hint: start at 10 and use i -= 2 as your update.

Think About It

• What happens if you accidentally use i++ instead of i--?
• How does the direction of counting affect your condition?

Tracing and Understanding the For Loop

Tracing a for loop in Java means following its logic step-by-step — watching how the counter changes, how the condition is checked, and when the program decides to stop. It’s one of the most effective ways to understand how iteration actually works under the hood.

Let’s use this example:

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

Before the Loop Starts

• The variable i is created and given an initial value of 1.
• The condition i <= 5 is checked for the first time.
• If the condition is true, the loop body runs; if false, the loop skips entirely.

During the Loop

1. Java checks the condition i <= 5.
2. If it’s true, the body executes: System.out.println("i = " + i);.
3. After execution, i++ increases the value of i by one.
4. The program then loops back to recheck the condition.

After the Loop

• When i becomes 6, the condition i <= 5 is false.
• The loop stops automatically, and the program continues with the next statement.

Tracing Table

Key Things to Remember

• The condition decides how long the loop runs.
• The update controls how quickly it progresses.
• The loop stops automatically once the condition becomes false.
• Forgetting to update the counter causes an infinite loop.

Try It Yourself

for (int i = 2; i <= 10; i += 2) {
    System.out.println(i);
}

Can you trace what happens to i from start to end? Write down the value before, after, and what’s printed during each iteration.

Challenge

for (int x = 3; x <= 9; x += 3) {
    System.out.println("x = " + x);
}

Predict the output before running it in your IDE. Then test your guess. Were you correct? If not, identify where your logic differed from Java’s actual execution.

Common Errors in For Loops

Small slips in a for loop in Java can lead to big bugs. Use these patterns to spot and fix issues fast.

1) Forgetting the Update

for (int i = 1; i <= 5; ) {  // i++ is missing
    System.out.println(i);
}

What happens: i never changes. The condition stays true. The loop never ends.

// Fix
for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

2) Wrong Comparison Operator

for (int i = 1; i < 5; i++) {
    System.out.println(i);   // Prints 1..4 only
}

What happens: you miss the end value by one.

// Fix (include 5)
for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

3) Stray Semicolon After the Header

for (int i = 1; i <= 5; i++); {  // ← wrong semicolon
    System.out.println("Runs once, not inside the loop");
}

What happens: the loop has an empty body. Your block runs once, outside the loop.

// Fix
for (int i = 1; i <= 5; i++) {
    System.out.println("Inside the loop");
}

4) Using the Loop Variable Outside Its Scope

for (int i = 1; i <= 3; i++) {
    System.out.println(i);
}
System.out.println(i);  // Error: i is out of scope

What happens: i only exists inside the loop.

// Fix: declare before the loop if you need it later
int i;
for (i = 1; i <= 3; i++) {
    System.out.println(i);
}
System.out.println("Final value of i: " + i);

5) Mismatch Between Condition and Update

for (int i = 10; i <= 20; i--) {  // counting down with an increasing-bound condition
    System.out.println(i);        // Never stops
}

What happens: the condition never becomes false.

// Fix: align direction and bound
for (int i = 10; i <= 20; i++) {
    System.out.println(i);
}

6) Off-by-One Errors

for (int i = 0; i <= 5; i++) {  // runs 6 times: 0..5
    // ...
}

What happens: you run one extra iteration.

// Fix for exactly 5 runs
for (int i = 1; i <= 5; i++) {
    // ...
}

Tips to Avoid Mistakes

• Align the update direction with the condition.
• Trace a few iterations on paper before you run the code.
• Remove any semicolon that sneaks after the for(...) header.
• Keep scope in mind when you need the loop counter later.

Mini Practice

for (int x = 5; x >= 1; x++) {
    System.out.println(x);
}

Will it stop? Why? Identify the mismatch, then rewrite it so the loop terminates predictably.

Practice Activities

Activity 1 – Sum of Numbers

Ask for n. Compute the sum from 1 to n using a for loop in Java.

import java.util.Scanner;

public class SumNumbers {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();
        int sum = 0;

        for (int i = 1; i <= n; i++) {
            sum += i;
        }

        System.out.println("The sum is: " + sum);
    }
}

Sample Run

Enter a number: 5
The sum is: 15

• Challenge: Sum only even numbers up to n.
• Hint: Use i += 2 and start at 2.

Activity 2 – Multiplication Table

Ask for a number. Print its table from 1 to 10. Keep the output clean and aligned.

import java.util.Scanner;

public class MultiplicationTable {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int n = sc.nextInt();

        for (int i = 1; i <= 10; i++) {
            System.out.println(n + " x " + i + " = " + (n * i));
        }
    }
}

Example Output

Enter a number: 4
4 x 1 = 4
4 x 2 = 8
...
4 x 10 = 40

Activity 3 – Squares of Numbers

Print a two-column list: number and its square. Use count-based iteration in Java.

public class Squares {
    public static void main(String[] args) {
        System.out.println("Number\tSquare");
        for (int i = 1; i <= 10; i++) {
            System.out.println(i + "\t" + (i * i));
        }
    }
}

Expected Output (partial)

Number  Square
1       1
2       4
3       9
...
10      100

• Try: Extend the range to 20. What pattern do you notice?

Activity 4 – Countdown by Twos

Count down from 20 to 0 in steps of 2. End with a message.

public class CountdownByTwos {
    public static void main(String[] args) {
        for (int i = 20; i >= 0; i -= 2) {
            System.out.println(i);
        }
        System.out.println("Blast off!");
    }
}

Expected Output (partial)

20
18
16
...
2
0
Blast off!

Activity 5 – Star Pattern

Print a left-aligned triangle using a for statement. Keep it simple.

public class StarPattern {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            String row = "";
            for (int j = 1; j <= i; j++) {
                row += "*";
            }
            System.out.println(row);
        }
    }
}

Expected Output

*
**
***
****
*****

• Challenge: Print the reverse triangle.
• Tip: Start from 5 and decrement the inner loop.

Which one will you try first? Trace a few iterations on paper before running the code. Spot the pattern. Own the logic.

Lesson Summary

The for loop in Java allows you to repeat tasks a fixed number of times with clear control over:

• Where to start (initialization)
• When to stop (condition)
• How to move (update)

Key Takeaways

• Use a for loop when the number of repetitions is known.
• Keep the condition and update consistent to avoid infinite loops.
• Each repetition is called an iteration.
• Forgetting the update or writing the wrong condition causes logic errors.
• Tracing helps you see how the loop executes step by step.

In simple terms, a for loop gives your computer a precise instruction: Start counting here, stop there, and move by this amount each time. Once you set it up, Java handles the repetition for you.

Self-Check Questions

1. What are the three main parts of a for loop?
2. Why is the for loop ideal for fixed repetition tasks?
3. What happens if you remove the update part?
4. How do you make a loop count backward?
5. Why is tracing your loop important before running the code?

Try answering these before you move on. If you can explain each one clearly, you’ve mastered the core logic of for looping statements in Java.