<h2>Fundamentos dos Laços de Repetição</h2>
<p>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: <code>for</code>, <code>while</code>, <code>foreach</code> e <code>do-while</code>. Cada um tem seu propósito específico, e escolher o correto impacta legibilidade e performance do seu código.</p>
<p>A diferença fundamental entre eles está no momento de avaliação da condição e na sintaxe de inicialização. Enquanto <code>for</code> e <code>while</code> avaliam a condição antes de executar, <code>do-while</code> garante pelo menos uma execução. O <code>foreach</code> é especializado em coleções. Compreender essas diferenças permite escrever código mais limpo e eficiente.</p>
<h2>O Laço for: Controle Total com Inicialização</h2>
<p>O <code>for</code> é 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.</p>
<h3>Sintaxe e Uso Básico</h3>
<pre><code class="language-java">// 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</code></pre>
<p>Na prática profissional, o <code>for</code> 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 <code>foreach</code> nesses casos.</p>
<h3>Laços Aninhados e Padrões Comuns</h3>
<pre><code class="language-java">// 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</code></pre>
<h2>O Laço while: Condição Dinâmica</h2>
<p>O <code>while</code> 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.</p>
<h3>Padrões de Uso</h3>
<pre><code class="language-java">// 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</code></pre>
<p>A principal armadilha do <code>while</code> é criar um laço infinito acidentalmente. Sempre verifique se a condição será eventualmente falsa. Em código legado, <code>while(true)</code> com <code>break</code> é aceitável, mas prefira estruturas mais claras.</p>
<h2>foreach e do-while: Casos Especializados</h2>
<h3>O Laço foreach: Elegância e Segurança</h3>
<p>O <code>foreach</code> (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.</p>
<pre><code class="language-java">// 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);
}</code></pre>
<p>Quando você não precisa do índice, <code>foreach</code> é 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.</p>
<h3>O Laço do-while: Execução Garantida</h3>
<p>O <code>do-while</code> executa o bloco de código <strong>pelo menos uma vez</strong>, verificando a condição apenas após. Use para menus interativos ou validações onde uma tentativa inicial é necessária.</p>
<pre><code class="language-java">// 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);</code></pre>
<h2>Conclusão</h2>
<p>Os quatro tipos de laços resolvem diferentes problemas. Use <strong><code>for</code></strong> quando souber o número exato de iterações; <strong><code>while</code></strong> para condições dinâmicas; <strong><code>foreach</code></strong> para iterar coleções de forma segura; e <strong><code>do-while</code></strong> 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á <code>foreach</code> e <code>while</code> em 90% dos casos—reserve <code>for</code> tradicional para situações específicas e <code>do-while</code> para validações e menus.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/for.html" target="_blank" rel="noopener noreferrer">Java Tutorials - The for Statement</a></li>
<li><a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/while.html" target="_blank" rel="noopener noreferrer">Java Tutorials - The while and do-while Statements</a></li>
<li><a href="https://www.oreilly.com/library/view/effective-java-3rd/9780134685991/" target="_blank" rel="noopener noreferrer">Effective Java - Joshua Bloch</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration" target="_blank" rel="noopener noreferrer">MDN - Loops and Iteration</a></li>
<li><a href="https://www.oreilly.com/library/view/clean-code-a/9780136083238/" target="_blank" rel="noopener noreferrer">Clean Code - Robert C. Martin</a></li>
</ul>