Laços aninhados e seu uso

1. Introdução

Vamos começar com a pergunta: para que serve, afinal, colocar um laço dentro de outro? A questão é que, muitas vezes, nossos dados ou tarefas não são organizados apenas em uma linha, mas, por exemplo, em uma tabela, grade ou até em uma estrutura multidimensional. Suponha que você queira exibir a tabuada na tela, percorrer um array bidimensional ou recalcular interseções entre todos os pares de elementos. Aqui, um único laço claramente não é suficiente — é preciso um laço dentro de outro.

Em programação, um laço aninhado é como dois alarmes: o externo começa a tocar e, dentro dele, inicia-se outro, que tocará repetidamente enquanto o primeiro estiver ativo. Assim, enquanto ocorre uma iteração “externa”, o laço interno percorre todo o seu caminho (e faz isso de novo e de novo para cada iteração do externo).

Um bom exemplo — horas e minutos. As horas são o laço externo de 0 a 23, os minutos são o laço interno de 0 a 59. A cada mudança no laço externo, o interno percorre todos os seus valores.

2. Sintaxe de laços aninhados

Em Java, a sintaxe de laços aninhados não difere em nada da dos laços comuns — você simplesmente escreve um laço dentro do corpo de outro. Vamos ver exemplos com for e while:

// Laço externo for
for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 4; j++)  // Laço interno for
    {
        System.out.print(i + "," + j + " ");
    }
    System.out.println(); // Nova linha após o laço interno
}

Aqui, o laço externo controla a variável i (de 0 a 2), e o interno — a variável j (de 0 a 3). Para cada valor de i, o laço interno percorre completamente de j == 0 até j == 3. Se você executar esse código, verá uma tabela agradável de coordenadas:

0,0 0,1 0,2 0,3 
1,0 1,1 1,2 1,3 
2,0 2,1 2,2 2,3 

Exemplo equivalente usando while:

int i = 0;
while (i < 3)
{
    int j = 0;
    while (j < 4)
    {
        System.out.print(i + "," + j + " ");
        j++;
    }
    System.out.println();
    i++;
}

Atenção: em cada passagem do laço externo, a variável do laço interno (j) deve ser inicializada novamente; caso contrário, veremos apenas uma linha!

3. Exemplos de funcionamento de laços aninhados

Exemplo 1: imprimir um tabuleiro de xadrez (8x8)

Suponha que nossa primeira tarefa seja exibir um tabuleiro de xadrez clássico como células pretas e brancas (vamos considerar ‘#’ — preta, ‘.’ — branca). Vamos implementar com laços aninhados for:

for (int row = 0; row < 8; row++)
{
    for (int col = 0; col < 8; col++)
    {
        // Se a soma dos índices de linha e coluna for par — a célula é branca; caso contrário, é preta
        if ((row + col) % 2 == 0)
            System.out.print("_");
        else
            System.out.print("#");
    }
    System.out.println(); // Quebra de linha após cada linha
}

Resultado:

_#_#_#_#
#_#_#_#_
_#_#_#_#
#_#_#_#_
_#_#_#_#
#_#_#_#_
_#_#_#_#
#_#_#_#_

Ponto importante: o aninhamento garante que, para cada linha (row), percorramos completamente todas as colunas (col). Sem o aninhamento, não obteríamos a estrutura do tabuleiro — apenas uma linha ou uma coluna.

Exemplo 2: tabuada

Um dos candidatos clássicos para laços aninhados! Vamos imprimir a tabuada de 1–9:

for (int i = 1; i <= 9; i++)
{
    for (int j = 1; j <= 9; j++)
    {
        System.out.print(i * j + "\t");
    }
    System.out.println();
}

A formatação i * j + "\t" adiciona tabulações para que a tabela fique alinhada.

Resultado:

  1   2   3   4   5   6   7   8   9 
  2   4   6   8  10  12  14  16  18 
  3   6   9  12  15  18  21  24  27 
  4   8  12  16  20  24  28  32  36 
...
  9  18  27  36  45  54  63  72  81 

4. Laços aninhados e seu controle — nuances

Sobre o efeito de break e continue em laços aninhados

É aqui que muitos iniciantes tropeçam! Se você usar break ou continue no laço interno, eles afetam apenas esse laço. O externo continua sua execução como se nada tivesse acontecido.

Exemplo: sair antecipadamente apenas do laço interno

for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 5; j++)
    {
        if (j == 3)
            break; // saímos apenas do laço interno!
        System.out.print(i + "," + j + " ");
    }
    System.out.println();
}

Resultado:

0,0 0,1 0,2 
1,0 1,1 1,2 
2,0 2,1 2,2 

Se você precisa sair de dois laços aninhados de uma vez (por exemplo, encerrar a busca assim que encontrar a primeira correspondência na tabela), geralmente usa-se um sinalizador (flag) ou uma técnica específica (por exemplo, return — se tudo estiver acontecendo dentro de um método).

5. Visualização de laços aninhados

Às vezes é difícil “ver” a sequência de execução de laços aninhados. Observe o seguinte fluxograma:

Em forma de tabela — quantas iterações haverá com i de 1 a 3, j de 1 a 4?

6. Erros e armadilhas ao trabalhar com laços aninhados

Um erro comum é inicializar incorretamente a variável do laço interno. Por exemplo, declará-la fora do laço externo e não redefini-la a cada passo. Como resultado, o laço interno pode nem ser executado ou funcionar de forma incorreta.

int j = 0;
for (int i = 0; i < 3; i++)
{
    while (j < 4) // Ops! j já pode ter sido igual a 4 após a primeira iteração.
    {
        System.out.print(i + "," + j + " ");
        j++;
    }
    System.out.println();
}

Aqui, o laço rodará apenas uma vez. Não se esqueça de inicializar as variáveis dos laços internos dentro dos externos!

Além disso, se você acidentalmente escrever dois laços aninhados com as mesmas variáveis (for (int i = 0; ...) { for (int i = 0; ...) { ... } }), o compilador reclamará: a variável já foi definida.