Praticando Java: laços for e while

Loops - Laços de repetição

Olá, meu nome é Jacqueline Oliveira, sou engenheira de software e instrutora na Alura.

Audiodescrição: Jacqueline é uma mulher de pele branca, com cabelos longos e reflexos loiros. Usa uma camiseta amarela e maquiagem leve. Na sua frente há um microfone. Ao fundo, uma parede lisa com iluminação azul e ao lado direito uma prateleira com vasos de planta, livros e itens de decoração.

Entendendo a importância dos laços de repetição

Uma estrutura fundamental no desenvolvimento de aplicações são os laços de repetição. Muitas vezes, lidamos com grandes volumes de dados e precisaremos executar uma determinada ação para cada um deles. Por exemplo, em uma empresa com 500 funcionários, calcular manualmente a comissão de cada um seria inviável. Em vez disso, utilizamos uma aplicação para realizar esse processo de forma eficiente, reduzindo o risco de erros e garantindo rapidez.

Os laços de repetição permitem automatizar essas execuções dentro do código. Sua lógica é simples: enquanto a condição for verdadeira, a ação será repetida. Quando a condição se tornar falsa, o laço será interrompido. É essencial garantir um ponto de parada para evitar o chamado loop infinito, que ocorre quando a condição nunca muda, impedindo a saída do laço.

Tipos de laços em Java

Em Java, contamos com três tipos de laços de repetição: for, while e do{} while(). Cada um possui uma sintaxe específica, que veremos tanto de forma teórica quanto aplicada no código.

O laço for segue uma estrutura com três elementos essenciais: ponto de inicialização, condição de execução e atualização. Esses elementos determinam quando o laço inicia, até quando será executado e como a variável de controle será atualizada a cada iteração.

Ao trabalhar com iteradores, declaramos uma variável de iteração, geralmente iniciando em zero. Definimos a condição com base no tamanho da lista de funcionários e atualizamos a variável de um em um (por exemplo, funcionário 1, funcionário 2, funcionário 3). Esse processo permite calcular a comissão de cada funcionário de forma automatizada.

O for é especialmente útil quando sabemos a condição final. Mesmo que a lista contenha 5 ou 500 funcionários, a condição de parada será sempre o tamanho da lista, garantindo um controle eficiente do fluxo de execução.

O laço while é ideal para situações em que não sabemos previamente o número de repetições necessárias. Por exemplo, ao cadastrar funcionários, podemos definir que, enquanto a ação de cadastro for verdadeira, o bloco de código será executado. A cada iteração, solicitamos os dados e perguntamos se deseja cadastrar outro funcionário. Como não há um número fixo de repetições, o laço pode ser executado uma ou duzentas vezes, dependendo das respostas.

Uma variação do while é o do{} while(). A principal diferença entre eles está na ordem de execução da condição. No while, a condição é verificada antes de entrar no bloco de código, podendo impedir sua execução caso já seja falsa na primeira verificação. Já no do{} while(), o bloco de código é executado pelo menos uma vez antes da verificação da condição, garantindo que a ação ocorra ao menos uma vez antes de uma possível interrupção.

Exemplo prático na IDE

Esses são os três laços mais comuns que utilizamos. Agora, vamos fazer uma análise prática. Para isso, abrimos a IDE, onde já temos um código pronto. Um deles é o método calcularComissao(), onde recebemos por argumento um total de vendas e, baseado no valor, aplicamos um percentual, seja 3%, 5% ou 7%.

package br.com.alura;

public class Principal {
    public static void main(String[] args) {
        String[] vendedores = {"Carlos", "Mariana", "João", "Fernanda"};
        double[] vendas = {4000.00, 8000.00, 12000.00, 5000.00};
    }
}

public static double calcularComissao(double totalVendas) {
    if (totalVendas <= 5000) {
        return totalVendas * 0.03;
    } else if (totalVendas <= 10000) {
        return totalVendas * 0.05;
    } else {
        return totalVendas * 0.07;
    }
}

No método principal, main, temos dois arrays: um com nomes de vendedores, contendo quatro vendedores, e outro com valores de vendas, também com quatro valores, representando as vendas de cada uma dessas pessoas. Por exemplo, 4 mil são as vendas do Carlos, 8 mil da Mariana, 12 mil do João e 5 mil da Fernanda.

Testando o for()

Precisamos calcular a comissão, então percorremos essa lista e chamamos o método calcularComissao() para que ele faça o cálculo. Vamos começar usando o for. Na IDE, temos um facilitador: ao digitar for, ele nos oferece opções para criar o esqueleto, uma prévia, também chamada de code snippet. Então, chamaremos o for i.

Quando utilizamos for i, criamos uma estrutura que já é familiar, onde i é um iterador comum em laços de repetição. A condição inicial é int i = 0, e a condição de parada é o tamanho da lista, como vendedores.length. O incremento é feito a cada iteração, passando pelas posições zero, um, dois, três, e assim por diante. No for, isso é feito automaticamente, mas no while ou do{} while(), precisamos incrementar manualmente.

Para formatar a saída, utilizamos System.out.printf(). Nos parênteses, dentro de aspas duplas, passamos %s - comissão %.2f, para formatar com duas casas decimais. O primeiro argumento substitui %s com vendedores[i], e o segundo substitui %.2f com o valor da comissão calculada pelo método calcularComissao(vendas[i]).

package br.com.alura;

public class Principal {

    public static void main(String[] args) {
        String[] vendedores = {"Carlos", "Mariana", "João", "Fernanda"};
        double[] vendas = {4000.00, 8000.00, 12000.00, 5000.00};

        for (int i = 0; i < vendedores.length; i++) {
            System.out.printf("%s - comissão %.2f\n", vendedores[i], calcularComissao(vendas[i]));
        }
    }

    public static double calcularComissao(double totalVendas) {
        if (totalVendas <= 5000) {
            return totalVendas * 0.03;
        } else if (totalVendas <= 10000) {
            return totalVendas * 0.05;
        } else {
            return totalVendas * 0.07;
        }
    }
}

Feito isso, clicamos no ícone de "Play", na lateral superior direita para executar o código. Assim, temos ao seguinte retorno:

Carlos - comissão 120,00

Mariana - comissão 1400,00

João - comissão 840,00

Fernanda - comissão 150,00

Foi rápido realizar essa tarefa para quatro pessoas, e o mesmo aconteceria para quinhentas. Bastou programar um laço de repetição com uma instrução clara. Essa é a grande vantagem dos laços de repetição: automatizar processos e otimizar o tempo de execução.

Testando o while

Vamos agora testar com while. Para isso, abaixo e fora do for (), escrevemos System.out.prontln("\n Testanto com while"). Para conseguirmos fazer esse teste, precisamos de um novo iterador.

Criamos um novo iterador int j = 0 e uma variável booleana boolean imprimeOutro = true. Na linha abaixo, escrevemos while(imprimeOutro) {}.

Nas chaves, passamos o mesmo código que criamos anteriormente. Então, o copiamos e colamos. Feito isso, fazemos as mudanças necessárias, mudando de [i] para [j].

Após, precisamos incrementar o j++ e perguntamos se desejamos imprimir outro, passando System.out.println("Deseja imprimir outro?"). Para lermos essa resposta, usaremos a classe scanner. Então, fora do while, na linha acima, escrevemos Scanner leitura = new Scanner(System.in).

Vamos ler esse resultado em uma variável booleana. Então, dentro de while(), no fim do código, escrevemos imprimeOutro = leitura.nextBoolean(). O while() não sabe quantas vezes diremos que queremos imprimir outro.

System.out.println("\n Testando com while");
int j = 0;

boolean imprimeOutro = true;

Scanner leitura = new Scanner(System.in);

while (imprimeOutro) {
    System.out.printf("%s - comissão %.2f\n", vendedores[j], calcularComissao(vendas[j]));
    j++;
    System.out.println("Deseja imprimir outro?");
    imprimeOutro = leitura.nextBoolean()
}

Feito isso, executamos o código e temos o retorno abaixo.

Testando com while

Carlos - comissão 120,00

Deseja imprimir outro?

Respondemos com:

true

E temos o retorno abaixo:

Mariana - comissão 400,00

Deseja imprimir outro?

Escrevemos, então:

false

Assim, encerramos o laço. Essa é uma característica do while, encerramos o laço, mas sem saber quantas vezes a condição será verdadeira. Diferente da condição de for() em que garantimos que era para imprimir em todos os funcionários da lista.

Testando o do{} while()

No do while, garantimos que pelo menos uma vez o nome do funcionário seja impresso. Então, para fazermos esse teste, recortamos a linha while (imprimeOutro) e movemos para o fim do código, após o fechamento das chaves. No lugar, passamos o do {}, poid queremos que o primeiro funcionário seja impresso antes de verificar a condição.

do {
    System.out.printf("%s - comissão %.2f\n", vendedores[j], 
        calcularComissao(vendas[j]));

    j++;
    System.out.println("Deseja imprimir outro?");
    imprimeOutro = leitura.nextBoolean();
} while (imprimeOutro);

Feito isso, executamos o código e temos o seguinte retorno:

Testando com while

Carlos - comissão 120,00

Deseja imprimir outro?

Respondemos com:

false

Assim, o laço é interrompido. Mas, pelo menos o primeiro foi feito.

Testando o break e o continue

Além disso, podemos interromper ou continuar o laço com break e continue. Por exemplo, se não quisermos imprimir a comissão de Mariana, usamos if (vendedores[i].equalsIgnoreCase("mariana")) {}. Queremos imprimir o Carlos e sair do laço. Para isso, nas chaves, passamos break.

//Código omitido

for (int i = 0; i < vendedores.length; i++) {
    if (vendedores[i].equalsIgnoreCase("mariana")) {
        break;
    }
}

//Código omitido

Carlos - comissão 120,00

Testando com while

Carlos - comissão 120,00

Deseja imprimir outro?

Ao executar, notamos que imprime a comissão do Carlos e sai do laço, então, deu certo. Respondemos conforme abaixo:

false

O break interrompe o laço, independente da posição. Agora, vamos testar o contrário, queremos imprimir todos menos Mariana. Sendo assim, substituímos o break por continue.

//Código omitido

for (int i = 0; i < vendedores.length; i++) {
    if (vendedores[i].equalsIgnoreCase("mariana")) {
        continue;
    }
}

//Código omitido

Ao executar, temos o retorno abaixo.

Carlos - comissão 120,00

João - comissão 840,00

Fernanda - comissão 150,00

Testando com while

Carlos - comissão 120,00

Deseja imprimir outro?

Testando o for each

Além dessas estruturas de laço, também temos o for each. Suponhamos que queremos imprimir o nome de todas as pessoas. Para isso, utilizamos System.out.println("Todos os nomes") e, em seguida, aplicamos o for each. Esse laço é uma versão aprimorada do for, ao entender automaticamente que estamos iterando sobre uma coleção, dispensando a necessidade de definir um ponto inicial e final manualmente.

Para testar, passamos for (String nomeVendedor: vendedores) {}. Nas chaves, passamos o System.out.println("Nome: " + nomeVendedor).

//Código omitido

for (String nomeVendedor : vendedores) {
    System.out.println("Nome: " + nomeVendedor);
}

Ao executar, temos o seguinte retorno:

Todos os nomes

Nome: Carlos

Nome: Mariana

Nome: João

Nome: Fernanda

Esse laço de repetição é adequado quando queremos imprimir ou fazer ações sem precisar do índice.

Pratique bastante e, se tiver dúvidas, entre em contato conosco pelo fórum ou Discord. Compartilhe seus projetos e deixe sua opinião sobre o curso. Até o próximo curso!

Sobre o curso Praticando Java: laços for e while

O curso Praticando Java: laços for e while possui 20 minutos de vídeos, em um total de 15 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Loops