Fundamentos dos Laços de Repetição
Um laço de repetição é uma estrutura de controle que permite executar um bloco de código múltiplas vezes sem duplicação. Em programação profissional, dominá-los é essencial para processar coleções de dados, validações repetidas e automação de tarefas. Existem quatro tipos principais: for, while, foreach e do-while. Cada um tem seu propósito específico, e escolher o correto impacta legibilidade e performance do seu código.
A diferença fundamental entre eles está no momento de avaliação da condição e na sintaxe de inicialização. Enquanto for e while avaliam a condição antes de executar, do-while garante pelo menos uma execução. O foreach é especializado em coleções. Compreender essas diferenças permite escrever código mais limpo e eficiente.
O Laço for: Controle Total com Inicialização
O for é ideal quando você sabe exatamente quantas vezes o laço deve executar. Sua sintaxe três componentes: inicialização, condição e incremento, oferecendo controle total sobre o fluxo.
Sintaxe e Uso Básico
// Exemplo 1: Iteração simples
for (int i = 0; i < 5; i++) {
System.out.println("Iteração: " + i);
}
// Saída: Iteração: 0, 1, 2, 3, 4
// Exemplo 2: Processando array
int[] notas = {7, 8, 9, 6, 10};
int soma = 0;
for (int i = 0; i < notas.length; i++) {
soma += notas[i];
}
System.out.println("Média: " + (soma / notas.length)); // Saída: 8
Na prática profissional, o for tradicional é útil quando você precisa acessar índices ou controlar o incremento de forma não-linear. Evite usá-lo para simplesmente iterar coleções—use foreach nesses casos.
Laços Aninhados e Padrões Comuns
// Exemplo 3: Tabuada com for aninhado
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
System.out.print((i * j) + " ");
}
System.out.println();
}
// Saída: 1 2 3 | 2 4 6 | 3 6 9
O Laço while: Condição Dinâmica
O while executa enquanto uma condição for verdadeira, sendo ideal para situações onde o número de iterações não é conhecido antecipadamente. Use quando a condição depende de fatores externos ou cálculos durante o loop.
Padrões de Uso
// Exemplo 4: Validação de entrada
Scanner entrada = new Scanner(System.in);
int numero = 0;
while (numero < 1 || numero > 10) {
System.out.print("Digite um número entre 1 e 10: ");
numero = entrada.nextInt();
}
System.out.println("Número válido: " + numero);
// Exemplo 5: Processamento de dados
int contador = 0;
while (contador < 100) {
contador += 10;
if (contador % 30 == 0) {
System.out.println("Múltiplo de 30: " + contador);
}
}
// Saída: Múltiplo de 30: 30, 60, 90
A principal armadilha do while é criar um laço infinito acidentalmente. Sempre verifique se a condição será eventualmente falsa. Em código legado, while(true) com break é aceitável, mas prefira estruturas mais claras.
foreach e do-while: Casos Especializados
O Laço foreach: Elegância e Segurança
O foreach (também chamado de "for-each" ou "enhanced for") é sintaxe açúcar para iterar coleções sem risco de índices inválidos. É o padrão moderno para trabalhar com listas, arrays e outros iteráveis.
// Exemplo 6: Foreach com array
String[] frutas = {"maçã", "banana", "laranja"};
for (String fruta : frutas) {
System.out.println("Fruta: " + fruta);
}
// Exemplo 7: Foreach com ArrayList
ArrayList<Integer> valores = new ArrayList<>();
valores.add(100);
valores.add(200);
valores.add(300);
for (Integer valor : valores) {
System.out.println("Valor: " + valor);
}
Quando você não precisa do índice, foreach é sua escolha. É mais legível, menos propenso a erros e moderno. Desvantagem: não funciona com acesso reverso nem permite modificar a coleção durante iteração.
O Laço do-while: Execução Garantida
O do-while executa o bloco de código pelo menos uma vez, verificando a condição apenas após. Use para menus interativos ou validações onde uma tentativa inicial é necessária.
// Exemplo 8: Menu com do-while
int opcao = 0;
Scanner entrada = new Scanner(System.in);
do {
System.out.println("Menu:");
System.out.println("1. Iniciar");
System.out.println("2. Sair");
System.out.print("Escolha: ");
opcao = entrada.nextInt();
if (opcao == 1) {
System.out.println("Sistema iniciado!");
}
} while (opcao != 2);
// Exemplo 9: Validação com retry
int tentativas = 0;
boolean sucesso = false;
do {
System.out.print("Digite a senha: ");
String senha = entrada.nextLine();
if (senha.equals("1234")) {
sucesso = true;
System.out.println("Acesso concedido!");
} else {
tentativas++;
System.out.println("Senha incorreta. Tentativas: " + tentativas);
}
} while (!sucesso && tentativas < 3);
Conclusão
Os quatro tipos de laços resolvem diferentes problemas. Use for quando souber o número exato de iterações; while para condições dinâmicas; foreach para iterar coleções de forma segura; e do-while quando precisar garantir pelo menos uma execução. Escolher o tipo correto torna seu código mais legível, eficiente e profissional. Na prática, você usará foreach e while em 90% dos casos—reserve for tradicional para situações específicas e do-while para validações e menus.