Laço while: introdução e nuances de uso

1. Introdução

Na programação, muitas vezes é preciso executar as mesmas ações repetidamente. Por exemplo:

• Percorrer todos os elementos de uma lista.
• Ler valores do teclado até que o usuário digite o correto.
• Somar todos os números de 1 a 100.
• Solicitar a senha do usuário até que ela esteja correta.

Se tentar fazer tudo isso sem laços, o código fica longo, entediante e pouco escalável. Imagine que você está escrevendo uma calculadora e decide somar os números de 1 a 10 manualmente:

int sum = 0;
sum = sum + 1;
sum = sum + 2;
sum = sum + 3;
// ... e assim 10 vezes. Pois é.

Você vai ficar entediado antes de terminar! A solução são os laços. Eles permitem descrever repetições de forma concisa e clara. Hoje vamos conhecer o laço mais básico, porém extremamente útil — while.

2. Conhecendo o laço while

Sintaxe e esquema básico

O laço while é o “papagaio” do mundo da programação: ele repete o mesmo trecho de código enquanto uma certa condição é verdadeira. Assim que a condição deixa de ser verdadeira, o papagaio se cala (o laço termina).

Sintaxe:

while (uslovie)
{
    // Corpo do laço
}

Diagrama

Aqui está um fluxograma simples para entender como o laço while funciona:

3. Exemplos: o laço while em ação

Contador clássico

Vamos fazer um programa simples que conta de 1 a 5 e imprime os números:

int i = 1;
while (i <= 5)
{
    System.out.println("Passo № " + i);
    i++; // Não se esqueça de incrementar o contador!
}
// Vai imprimir:
// Passo № 1
// Passo № 2
// Passo № 3
// Passo № 4
// Passo № 5

Atenção: se você esquecer de incrementar a variável i, o laço nunca terminará (nosso papagaio se tornará imortal e repetirá para sempre). Isso se chama laço infinito — algo perigoso.

Leitura do teclado até o valor desejado

Muitas vezes o laço é usado para “insistir” até que o usuário forneça a resposta correta:

String password = "";
while (!password.equals("qwerty"))
{
    System.out.print("Digite a senha: ");
    password = console.nextLine();
}
System.out.println("Bem-vindo!");

Aqui o programa pede a senha até você digitar o mágico "qwerty". Não se esqueça: se remover a linha password = console.nextLine();, o laço se tornará infinito (ele continuará pedindo a senha, mas não lerá a entrada — ficará preso para sempre, como um robô quebrado).

4. Tipos e cenários de uso do laço while

Laço while comum

Esse laço, como mostrado acima, verifica a condição antes da primeira iteração. Se a condição for falsa de imediato, o corpo do laço não será executado nenhuma vez.

Exemplo: a condição é falsa desde o início

int i = 10;
while (i < 5)
{
    System.out.println(i); // Nunca será executado!
}

O que, convenhamos, é bastante lógico. É exatamente isso que está escrito.

Laços while aninhados

Às vezes é preciso colocar um laço dentro de outro. Por exemplo, percorrer todas as linhas e, em cada uma, verificar todos os caracteres. Neste momento isso é mais uma aventura, mas aqui vai um exemplo simples:

int i = 1;
while (i <= 3)
{
    int j = 1;
    while (j <= 2)
    {
        System.out.println("i = " + i + ", j = " + j);
        j++;
    }
    i++;
}

// i = 1, j = 1
// i = 1, j = 2
// i = 2, j = 1
// i = 2, j = 2
// i = 3, j = 1
// i = 3, j = 2

Veremos laços aninhados com mais detalhes em algumas aulas; por enquanto era só para dar um sustinho :)

Laço infinito

Às vezes os laços terminam e, às vezes, vivem para sempre.

while (true)
{
    System.out.println("Sou eterno!");
}

É usado raramente, geralmente para algum processo em segundo plano (por exemplo, um servidor), mas também aparece na prática.

5. Como evitar bobagens: erros comuns com while

Na programação, um laço é como eletricidade: é ótimo, mas é preciso conhecer as regras de segurança.

Problema 1: laço infinito por descuido

Com muita frequência, iniciantes esquecem de atualizar a variável da qual a condição depende. Como resultado, o laço roda “para sempre” e é preciso encerrar o programa à força (por exemplo, com Ctrl + C).

int i = 1;
while (i <= 5)
{
    System.out.println(i);
    // i++;  // OPS! Esquecemos de incrementar i
}

Problema 2: condição incorreta

Às vezes o desenvolvedor cava a própria cova: a condição nunca é verdadeira. Resultado: o laço não é executado de forma alguma.

int i = 10;
while (i < 5)
{
    System.out.println(i); // Este código nunca será executado.
    i++;
}

Problema 3: erro com tipos de dados

Na condição do laço deve haver sempre uma expressão booleana — ou seja, o resultado da avaliação deve ser true ou false.

int number = 5;
while (number) // Erro! Esperava-se boolean, não int.
{
    number--;
}