Estruturas de repetições em Java (for, while, do-while, for-each)

Texto de: Geraldo Daros

Introdução

Laços de repetição são estruturas muito importantes dentro do mundo da programação, mas entender como utilizar e tirar vantagem dessas estruturas pode ser muito desafiador. Os laços, ou loops, possuem vários detalhes que podem gerar efeitos indesejados, e nesse artigo todos esses detalhes serão abordados e explicados com detalhes.

for

A estrutura de repetição for é usada quando o número de iterações é conhecido antecipadamente. A sintaxe básica do for é a seguinte:

for (inicialização; condição; atualização) { 
    // bloco de código a ser repetido 
} 

• Inicialização: esta etapa é executada apenas uma vez no início no laço e é a etapa onde você pode criar e inicializar uma variável que vai ser usada para o controle do laço.
• Condição: esta etapa ocorre antes de cada iteração do laço e é a etapa onde uma condição é verificada. Se essa condição for verdadeira, o loop continua a ser executado. Se a condição for falsa, o loop é encerrado.
• Atualização: esta etapa é executada após cada iteração do laço. Normalmente, nesta etapa colocamos um código que altere o valor da variável criada na etapa de inicialização, sendo que as operações mais comuns são o decremento e o incremento dessa variável.

Por exemplo, o seguinte código usa o loop “for” para imprimir os números de 1 a 5:

for (int i = 1; i <= 5; i++) {
    System.out.println(i);
} 

Resultado:

1
2
3
4
5

No código acima, a variável i foi inicializada com o valor 1. Depois disso, a condição é verificada e como i tem o valor 1, que é menor ou igual a 5, o bloco de código é executado. Depois da execução do código que está dentro do loop, a parte de atualização é chamada, e então, a variável i é incrementada em 1, passando a ter o valor 2. Uma vez que isso tenha acontecido, a condição é verificada novamente, o código é executado e variável é atualizada. Isso é repetido até que em uma das avaliações da condição, essa seja falsa. O fluxo funciona dessa forma:

Vale lembrar que a etapa 1 só é executada na primeira execução do laço. Após a primeira execução, o Java só executará as etapas 2, 3 e 4.

while

A estrutura de repetição while é usada quando o número de iterações não é conhecido antecipadamente. A sintaxe básica desse laço é a seguinte:

while (condição) {
     // bloco de código a ser repetido
} 

O bloco de código é executado repetidamente enquanto a condição for verdadeira. Se a condição for falsa, o loop é encerrado.

Por exemplo, o seguinte código usa o loop while para imprimir os números de 1 a 5:

int i = 1;
while (i <= 5) {
    System.out.println(i);
    i++;
} 

Neste exemplo, a variável i é inicializada com o valor 1 e antes mesmo do código dentro do loop ser executado, a condição i <=5 é avaliada. Se esta for avaliada para como verdadeira, o código dentro do laço será executado. Neste caso, o código dentro do laço faz a impressão do valor de i e incrementa essa variável, o que é seguido pela avaliação da condição e novamente pela execução do código dentro do laço. Esse processo se repete até que a condição seja avaliada como falsa.

Agora, faremos um algoritmo um pouco mais elaborado, também usando o laço while. A intenção é criarmos um número aleatório entre 0 e 10, e então pedir para o usuário tentar acertar dando palpites no console, o nosso loop acontecerá infinitamente enquanto o usuário não acertar o número “sorteado”.

Segue código inteiro:

import java.util.Scanner;

public class NumeroAleatorioWhile  {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int resposta = (int) (Math.random() * 10) + 1;
        int palpite = 0;
        boolean controlador = true;

        while (controlador) {

            System.out.println("Tente adivinhar um número entre 1 e 10.");
            palpite = Integer.parseInt(scanner.nextLine());

            if (palpite == resposta) {
                System.out.println("Parabéns, você conseguiu! :D");
                controlador = false;
            } else {
                System.out.println("Chegou perto, quase lá!");
            }
        }

    }
} 

Note que estamos usando o while considerando uma variável chamada controlador, essa variável começa com o valor true, o que permite que a primeira execução do laço aconteça. Uma vez no laço, a lógica será executada e o loop acontecerá normalmente. Note que, só estamos alterando o valor do controlador para false quando o usuário acertar o palpite, ou seja, toda vez que o loop acontecer, se o usuário não acertar o palpite o valor de controlador continuará sendo true, e o loop acontecerá até o usuário acertar o palpite.

do-while

A estrutura de repetição do-while é semelhante ao while, mas garante que o bloco de código do laço seja executado pelo menos uma vez, já que a condição é validada após a execução do bloco de código, e não antes como no for e no while. A sintaxe básica do do-while é a seguinte:

do {
    // bloco de código a ser repetido
} while (condicao); 

Neste laço, o bloco de código é executado primeiro e depois da execução a condição é verificada. Se a condição for verdadeira, o bloco de código será executado novamente, caso contrário, a execução do laço é encerrada.

Um exemplo do uso do do-while é pedir ao usuário para fornecer uma informação, até que ele a digite de forma válida.

import java.util.Scanner;

public class DoWhile {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int input;
        do {
            System.out.print("Digite um número entre 1 e 10: ");
            input = scanner.nextInt();
        } while (input < 1 || input > 10);

        System.out.println("Você digitou: " + input);
    }
}
 

Este código pede ao usuário para digitar um número entre 1 e 10 e, em seguida, verifica se o número digitado está dentro desse intervalo. Se o número não estiver no intervalo, o usuário será solicitado a digitar outro número até que um número válido seja inserido.

for-each

O laço for-each, também chamado de for aprimorado, é uma variação do loop for tradicional. Ele foi introduzido no Java 5 para simplificar a iteração em arrays e coleções e deixar mais simples sua implementação e sua leitura.

O for-each funciona de maneira similar ao laço for tradicional, mas em vez de iterar sobre uma faixa de valores, ele itera sobre cada elemento de um array ou coleção sequencialmente, de forma automática, sem que você precise se preocupar com índices ou variáveis de controle.

A sintaxe do for-each é a seguinte:

for (Tipo variável: array) { 
    // instruções 
} 

• Tipo : tipo dos elementos da coleção ou do array.
• variável : nome da variável que representa cada elemento da coleção ou do array durante a iteração, o valor da variável mudará a cada iteração.
• array : a coleção ou o array a ser percorrido.

Aqui está um exemplo simples de como usar o for-each loop para percorrer um array de inteiros:

int[] numeros = { 1, 2, 3, 4, 5 };
for (int numero: numeros) {
    System.out.println(numero);
}  

O loop percorre o array numeros e atribui cada elemento a variável numero. Em seguida, o bloco de código no loop é executado para cada elemento. Nesse momento temos acesso à variável numero e o seu conteúdo, lembrando que a cada execução do loop o valor da variável numero mudará e será o valor do próximo valor do array ou coleção. No exemplo acima, a saída do programa seria:

1
2
3
4
5

Esse laço pode ser usado para percorrer qualquer tipo de coleção ou array, incluindo listas, conjuntos e maps. Além disso, ele permite reduzir o código necessário para percorrer uma coleção e para evitar erros relacionados à manipulação de índices.

É importante ressaltar que o for-each loop não é adequado para todas as situações, como quando é necessário obter o índice do elemento atual ou quando é necessário alterar o conteúdo da coleção durante a iteração. Nesses casos, o loop for pode ser usado em vez do for-each loop.

Conclusão

Os loops for, while e do-while são essenciais para a programação em Java. Cada um desses loops tem suas próprias vantagens e desvantagens, e é importante escolher o tipo de loop correto para a tarefa que você está tentando realizar. Com a prática e a experiência, você poderá determinar facilmente qual tipo de loop é o melhor para cada situação. Com esse artigo você tem uma ótima noção sobre os loops mais importantes e como usá-los.