Nested Loops in Java: Working With Loops Inside Loops

final int SIZE = 3;
for (int row = 1;
row <= SIZE;
row++) {
    for (int col = 1;
    col <= SIZE;
    col++) {
        System.out.print(row + "," + col + " ");
    } System.out.println();
}

That prints a 3 by 3 grid. Read it carefully: the outer loop counts row, and every time it advances one step, the inner loop starts again from the beginning and runs all three columns.

row is 1 -> col runs 1, 2, 3row is 2 -> col runs 1, 2, 3(from scratch again)row is 3 -> col runs 1, 2, 3(from scratch again)

The inner counter is re-initialised on every pass of the outer loop. That is the whole mechanic, and everything else follows from it.

This is worth a small table, because the growth is what makes nesting expensive rather than merely powerful.

And with three levels of nesting it gets dramatically worse, because the multiplication happens twice.

final int SIZE = 1000;
for (int a = 0;
a < SIZE;
a++) {
    // 1,000 iterations
    for (int b = 0;
    b < SIZE;
    b++) {
        // 1,000 each  = 1,000,000
        for (int c = 0;
        c < SIZE;
        c++) {
            // 1,000 each  = 1,000,000,000
            // one billion times over
        }
    }
}

One billion iterations of even a trivial statement will visibly freeze your program. This is the single most important practical fact on the page, and it is why nesting three or more levels deep over large collections is something to avoid rather than optimise later.

The inner loop does not have to match the outer one. A very common shape is an outer for-each over a collection with an inner for over a range.

String[] products = {
    "Book", "Pen", "Bag"
};
final int MAX_ITEMS = 2;
for (String product : products) {
    for (int count = 1;
    count <= MAX_ITEMS;
    count++) {
        System.out.println(count + " x " + product);
    }
}

That prints every product at two quantities. A for-each outer loop is usually the better choice when you do not need the index, because it removes one whole class of off-by-one mistakes from the outer level. We compare the two forms on the enhanced for loop page.

This is the surprise that catches almost everyone. Inside nested loops, break and continue apply to the innermost loop only. There is no way for the inner loop to end the outer one without help.

final int SIZE = 3;
final int STOP_COLUMN = 2;
for (int row = 1;
row <= SIZE;
row++) {
    for (int col = 1;
    col <= SIZE;
    col++) {
        if (col == STOP_COLUMN) {
            break;
            // leaves the INNER loop only
        } System.out.print(row + "," + col + " ");
    } System.out.println();
}

Output is 1,1 on each of the three lines. The break skipped column 2 and 3, but the outer loop carried on to the next row regardless. If the intent was to stop everything, this code is wrong, and it is wrong silently.

A label is a name you attach to a loop. Put a name and a colon before the loop, then use it with break or continue to control that specific loop from anywhere inside.

final int SIZE = 3;
outer:for (int row = 1;
row <= SIZE;
row++) {
    for (int col = 1;
    col <= SIZE;
    col++) {
        if (row == col) {
            continue outer;
            // skip to the next ROW, not the next column
        } System.out.print(row + "," + col + " ");
    }
}

This prints every pair except the diagonal, which is exactly the shape you want when you are finding pairs that are not equal to each other.

Building a Multiplication Table

final int LIMIT = 5;
for (int i = 1;
i <= LIMIT;
i++) {
    for (int j = 1;
    j <= LIMIT;
    j++) {
        System.out.printf("%4d", i * j);
    } System.out.println();
}

Finding Duplicate Values

String[] names = {
    "Alex", "Sam", "Alex", "Robin", "Sam"
};
final int LENGTH = names.length;
for (int i = 0;
i < LENGTH;
i++) {
    for (int j = i + 1;
    j < LENGTH;
    j++) {
        if (names[i].equals(names[j])) {
            System.out.println("Duplicate found: " + names[i]);
        }
    }
}

Two details matter there. First, j starts at i + 1 rather than zero, so each pair is only compared once and a value is never compared with itself. Comparing a string needs equals(), not ==. Getting the inner start point wrong here is the classic off-by-one in a nested loop.

Walking a Two-Dimensional Array

int[][] grid = {
{
        1, 2, 3
    }, {
        4, 5, 6
    }
};
for (int row = 0;
row < grid.length;
row++) {
    for (int col = 0;
    col < grid[row].length;
    col++) {
        System.out.print(grid[row][col] + " ");
    } System.out.println();
}

Note the inner condition uses grid[row].length rather than a hard-coded number, so the code keeps working if the rows have different sizes.

There is a simple test you can apply before committing to a nested loop. Ask whether the work in the inner loop really depends on the outer value. If it does not, you almost certainly want a single loop that does the inner work once per item rather than repeatedly. Nesting exists for genuinely two-dimensional problems like grids and matrices, not as a general way to run some code several times.

The first one deserves emphasis. If both loops declare int i, the inner declaration shadows the outer one, and the outer counter becomes invisible inside the inner loop. The compiler rejects redeclaring in the same block but allows it in a nested one, so this fails in a confusing way rather than an obvious one.

Frequently Asked Questions

How many times does a nested loop body run?

The number of times the outer loop runs multiplied by the number of times the inner loop runs on each pass. Three passes of the outer loop with four inner iterations each means twelve executions of the inner body, not seven.

Does break exit both loops in a nested loop?

No. An unlabelled break exits only the innermost loop containing it. To exit the outer loop you must label it and write break labelName;, or use return to leave the method entirely.

What is a loop label and how do I use one?

A label is a name attached to a loop, written before it with a colon, as in outer: for (...). Inside that loop you can then write break outer; to leave it or continue outer; to skip to its next pass, regardless of how deeply nested you are.

When should I avoid nested loops?

When the inner work does not actually depend on the outer value, because then you can flatten it into a single loop. Also avoid three or more levels, since the cost multiplies at each level and the program becomes slow enough to appear frozen.

Can I use a for-each loop as the inner loop?

Yes, the two styles mix freely. Using a for-each inner loop removes index mistakes from that level, but remember it still re-runs from the first element on every pass of the outer loop, so it does not save iterations.

How do I compare every pair in a list exactly once?

Use an indexed outer loop starting at zero and an inner loop starting at i + 1. Starting the inner loop at zero instead would compare each pair twice and would also compare every element with itself.

Is a nested loop slower than a stream?

For simple transformations, a stream is usually faster because it avoids repeated work and reads closer to the intent. For genuinely two-dimensional problems such as grids and matrices, a nested loop is the natural and correct tool.

What happens if the inner loop never ends?

The outer loop simply never advances, so the program appears to hang on the first pass. Check the inner update expression first, exactly as you would with a single loop.