Estruturas de repetição

While, Do-While, For

Pessoal, como hoje é domingo, resolvi escrever mais um artigo — dessa vez sobre os famosos laços de repetição. Também é um assunto que não é muito complexo, mas requer atenção pra evitar loops infinitos ou ficar perdido sobre o que você está iterando!

Os laços fazem parte do famoso Controle de Fluxo: enquanto uma condição for verdadeira, o bloco de código continua executando.

While

O while simplesmente faz várias iterações enquanto a condição for verdadeira. Geralmente usamos quando não sabemos exatamente quantas vezes vamos precisar repetir. O exemplo mais clássico que costumamos ver é uma contagem:

int contador = 0;
while (contador < 10) {
    System.out.println("Contador: " + contador);
    contador++;
}

⚠️ A instrução contador++ é importantíssima! Se você esquecer de alterar a variável que controla o laço, vai entrar num loop infinito, travando a thread e consumindo CPU sem parar.

Lembrando: ++ incrementa (+1) e -- decrementa (-1). Dá pra contar pra trás também:

int contador = 10;
while (contador > 0) {
    System.out.println("Contador: " + contador);
    contador--;
}

Daí em diante é criatividade — dá pra fazer mil coisas com laços!

Do-While

O do-while segue o mesmo princípio. (E aqui, saber um pouquinho de inglês ajuda: “do while” = “faça enquanto”.) A diferença é que ele executa o bloco pelo menos uma vez e só depois avalia a condição:

int contador = 5;
do {
    System.out.println("Contador: " + contador);
    contador--;
} while (contador > 10);

Mesmo com a condição já falsa logo de cara (5 > 10 é falso), o println é executado uma vez antes da verificação. Esse é o ponto-chave do do-while.

For

Agora vamos pra parte que você vai usar praticamente todos os dias programando: o for. Não que você não vá usar while/do-while, mas o for é o que normalmente usamos pra iterar sobre arrays, listas e coleções — e isso é pão com manteiga no dia a dia.

For clássico (com índice)

String[] nomes = { "Goku", "Vegeta", "Gohan", "Broly" };

for (int i = 0; i < nomes.length; i++) {
    System.out.println(nomes[i]);
}

Aqui declaro uma variável local i (índice) que começa em 0, e enquanto ela for menor que o tamanho do array, o laço imprime o nome correspondente àquela posição. No fim de cada iteração, i é incrementado.

For-each (mais limpo)

Existe uma forma mais legível pra fazer a mesma coisa, o enhanced for (ou for-each):

String[] nomes = { "Goku", "Vegeta", "Gohan", "Broly" };

for (String nome : nomes) {
    System.out.println(nome);
}

Lê literalmente: “para cada nome em nomes, faça…”. Use sempre que não precisar do índice.

Bônus: forEach com lambda (Java 8+)

Pra quem está em coleções (List, Set, etc.), ainda existe o forEach com expressão lambda:

List<String> nomes = List.of("Goku", "Vegeta", "Gohan", "Broly");
nomes.forEach(nome -> System.out.println(nome));

Break e Continue

Diferente do while, no for é bem comum usarmos break e continue pra controlar o fluxo:

break → interrompe o laço imediatamente.

String[] nomes = { "Goku", "Vegeta", "Gohan", "Broly", "Majin Boo", "Freeza", "Cell" };

for (String nome : nomes) {
    if (nome.equals("Majin Boo")) {
        break;
    }
    System.out.println(nome);
}
// Imprime: Goku, Vegeta, Gohan, Broly

continue → pula a iteração atual e vai para a próxima.

for (String nome : nomes) {
    if (nome.equals("Majin Boo")) {
        continue;
    }
    System.out.println(nome);
}
// Imprime todos, menos Majin Boo

Esses dois são recursos preciosos — abrem várias portas dentro de uma lista. Vale praticar bastante!

Resumão

• while → executa enquanto a condição for verdadeira (pode nunca executar).
• do-while → executa pelo menos uma vez, depois testa a condição.
• for → ideal pra quando você sabe quantas vezes precisa iterar, ou pra percorrer arrays/coleções.
• for-each → versão limpa do for quando você não precisa do índice.
• break interrompe o laço; continue pula pra próxima iteração.

E aqui chegamos ao final de mais um artigo! Espero ter ajudado a esclarecer algo que você ainda não tinha entendido bem.

Até a próxima! 🚀