Java while e do-while

Até agora, cada linha do seu programa rodava uma vez. Mas muita coisa no dia a dia é repetição: contar de 1 a 10, guardar dinheiro todo mês até bater uma meta, pedir uma senha até a pessoa acertar. Para isso existem os laços (ou loops). Nesta aula você conhece os dois mais simples: o while e o do-while.

Todos os exemplos foram rodados no terminal da Ana, a usuária da máquina fictícia notebook, com o JDK 25, dentro da pasta ~/java. Para rodar, usamos o modo "arquivo-fonte" que você viu em javac e java: java Main.java compila e executa de uma vez.

A ideia antes do código

Imagine que a Ana está lavando a louça. Ninguém diz a ela "lave o prato 1, lave o prato 2, lave o prato 3…". A instrução é uma só:

Enquanto ainda houver louça suja na pia, lave mais uma peça.

Repare nas duas partes dessa frase:

• Uma pergunta que tem resposta sim ou não: "ainda há louça suja?". Em Java, é uma expressão booleana, que vale true ou false.
• Uma tarefa que se repete enquanto a resposta for "sim": "lave mais uma peça".

E tem um detalhe escondido, mas essencial: a tarefa muda a resposta da pergunta. Cada peça lavada deixa a pia mais vazia, até que um dia a resposta vira "não" e a Ana para. Se ela só olhasse para a pia sem lavar nada, ficaria ali para sempre. Guarde isso: é a causa número 1 dos laços infinitos, que você vai ver mais adiante.

while, em inglês, quer dizer exatamente enquanto.

O primeiro while: um contador

Vamos fazer o computador escrever "Volta 1" até "Volta 5". Sem laço, seriam cinco println iguais. Com laço:

public class Main {
    public static void main(String[] args) {
        int contador = 1;
        while (contador <= 5) {
            System.out.println("Volta " + contador);
            contador++;
        }
        System.out.println("Fim! O contador parou em " + contador);
    }
}

$ java Main.java
Volta 1
Volta 2
Volta 3
Volta 4
Volta 5
Fim! O contador parou em 6

Vamos ver linha por linha:

Anatomia do while

while

A palavra-chave: "enquanto".

(contador <= 5)

A condição, entre parênteses. Precisa dar true ou false. É testada antes de cada volta.

{

Abre o corpo do laço.

…

As instruções que se repetem. Uma delas precisa mudar algo da condição.

}

Fecha o corpo. Ao chegar aqui, o Java volta para a condição e testa de novo.

O que acontece, volta por volta

Programadores chamam cada repetição de iteração (do latim iterare, "repetir"). Acompanhe o valor do contador em cada teste da condição:

Repare em dois fatos que confundem muita gente:

• A condição foi testada 6 vezes, mas o corpo rodou 5. O último teste é o que dá false e encerra o laço.
• Depois do laço, o contador vale 6, e não 5. Foi justamente o 6 que fez a condição falhar. A saída "O contador parou em 6" confirma.

Contando para baixo

O passo não precisa ser ++. Para uma contagem regressiva, comece alto, teste com >= e diminua com --:

public class Main {
    public static void main(String[] args) {
        int contador = 10;
        while (contador >= 1) {
            System.out.println(contador);
            contador--;
        }
        System.out.println("Feliz Ano Novo!");
    }
}

$ java Main.java
10
9
8
7
6
5
4
3
2
1
Feliz Ano Novo!

public class Main {
    public static void main(String[] args) {
        int contador = 1;
        while (contador <= 5) {
            System.out.println(contador);
            contador++;
        }
        System.out.println("Fim");
    }
}

public class Main {
    public static void main(String[] args) {
        int contador = 5;
        while (contador >= 1) {
            System.out.println(contador);
            contador--;
        }
        System.out.println("Já!");
    }
}

Laços que não são contagem

O while brilha quando você não sabe de antemão quantas voltas serão. A Ana quer juntar R$ 1000 guardando R$ 150 por mês. Quantos meses? Em vez de fazer a conta de cabeça, deixe o laço descobrir:

public class Main {
    public static void main(String[] args) {
        double saldo = 0;
        int meses = 0;
        while (saldo < 1000) {
            saldo = saldo + 150;
            meses++;
            System.out.println("Mês " + meses + ": R$ " + saldo);
        }
        System.out.println("A meta de R$ 1000 foi atingida em " + meses + " meses.");
    }
}

$ java Main.java
Mês 1: R$ 150.0
Mês 2: R$ 300.0
Mês 3: R$ 450.0
Mês 4: R$ 600.0
Mês 5: R$ 750.0
Mês 6: R$ 900.0
Mês 7: R$ 1050.0             « 1050 não é menor que 1000: o laço para aqui
A meta de R$ 1000 foi atingida em 7 meses.

A condição agora é sobre o saldo, e não sobre um contador. A variável meses só conta quantas voltas foram dadas, para mostrar no final. (O .0 aparece porque saldo é um double, veja double e float.)

Outro exemplo: qual é a primeira potência de 2 que passa de 100? Comece em 1 e dobre enquanto for pequeno:

public class Main {
    public static void main(String[] args) {
        int numero = 1;
        while (numero < 100) {
            numero = numero * 2;
        }
        System.out.println("Primeira potência de 2 maior ou igual a 100: " + numero);
    }
}

$ java Main.java
Primeira potência de 2 maior ou igual a 100: 128

O número passou por 1, 2, 4, 8, 16, 32, 64 e 128. Quando chegou a 128, a condição 128 < 100 deu false e o laço parou.

Um while pode rodar zero vezes

Como a condição é testada antes da primeira volta, se ela já começar falsa, o corpo nunca roda. A loja da Ana tem um laço que vende uma unidade de cada vez enquanto houver estoque. E se o estoque já for zero?

public class Main {
    public static void main(String[] args) {
        int estoque = 0;
        while (estoque > 0) {
            System.out.println("Vendendo uma unidade...");
            estoque--;
        }
        System.out.println("Estoque final: " + estoque);
    }
}

$ java Main.java
Estoque final: 0             « o corpo do while nem chegou a rodar

Esse é o comportamento certo: não dá para vender o que não existe. Guarde este exemplo, porque o do-while vai se comportar de outro jeito.

O do-while: primeiro faz, depois pergunta

O do-while (do = "faça") é o while de cabeça para baixo: o corpo vem primeiro e a condição vem no fim. Por isso ele roda pelo menos uma vez, mesmo que a condição seja falsa desde o começo.

Uma comparação do dia a dia: provar a comida. Você prova primeiro e só depois decide se precisa de mais sal. Não dá para decidir antes de provar.

do

"Faça": marca o início do corpo.

{ … }

O corpo, que roda uma vez sem nenhum teste.

while

Depois da primeira volta, a pergunta "repito?".

(condição)

Se der true, volta para o do; se der false, segue em frente.

;

O ponto e vírgula obrigatório no fim. O while comum não tem; o do-while tem.

Veja a mesma loja, com estoque zero, agora com do-while:

public class Main {
    public static void main(String[] args) {
        int estoque = 0;
        do {
            System.out.println("Vendendo uma unidade...");
            estoque--;
        } while (estoque > 0);
        System.out.println("Estoque final: " + estoque);
    }
}

$ java Main.java
Vendendo uma unidade...      « rodou uma vez antes de testar a condição
Estoque final: -1            « vendeu o que não tinha!

A condição estoque > 0 era falsa desde o início, mas o corpo rodou uma vez antes de ela ser testada, e o estoque ficou negativo. Aqui o do-while foi a escolha errada. Ele é a escolha certa quando a primeira volta precisa acontecer, como ao pedir um dado ao usuário: você precisa perguntar uma vez antes de saber se a resposta é válida. É o que vem a seguir.

Validar a entrada com do-while

A Ana está fazendo um programa para lançar as notas da turma. A nota precisa estar entre 0 e 10. Se o professor digitar 15 por engano, o programa deve reclamar e pedir de novo, quantas vezes for preciso.

Para ler o que a pessoa digita, usamos o Scanner, que tem uma aula só para ele: Ler do Teclado (Scanner). Por enquanto, basta saber que teclado.nextInt() espera a pessoa digitar um número inteiro e apertar Enter.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        int nota;
        do {
            System.out.print("Digite uma nota de 0 a 10: ");
            nota = teclado.nextInt();
            if (nota < 0 || nota > 10) {
                System.out.println("Nota inválida! Tente de novo.");
            }
        } while (nota < 0 || nota > 10);
        System.out.println("Nota registrada: " + nota);
    }
}

Rodando no terminal, o professor digitou 15, depois -2 e por fim 8:

$ java Main.java
Digite uma nota de 0 a 10: 15
Nota inválida! Tente de novo.
Digite uma nota de 0 a 10: -2
Nota inválida! Tente de novo.
Digite uma nota de 0 a 10: 8
Nota registrada: 8

A mesma entrada, sem digitar

Você pode mandar as respostas prontas para o programa com o printf do terminal e um | (barra vertical, o "cano" que liga a saída de um comando à entrada do outro). Cada \n é um Enter:

$ printf '15\n-2\n8\n' | java Main.java
Digite uma nota de 0 a 10: Nota inválida! Tente de novo.
Digite uma nota de 0 a 10: Nota inválida! Tente de novo.
Digite uma nota de 0 a 10: Nota registrada: 8

O programa é o mesmo; a diferença está na tela. Quando você digita, o terminal mostra as teclas e o Enter pula a linha. Quando a entrada vem pelo |, ninguém digita nada, então os números não aparecem e as mensagens ficam emendadas. É assim também no editor do guia quando a caixa já traz a entrada pronta.

Laço infinito: quando a condição nunca fica falsa

Um laço infinito é um laço cuja condição nunca vira false. O programa fica preso dando voltas para sempre. Quase sempre é um engano, e o mais comum é esquecer o passo.

public class Main {
    public static void main(String[] args) {
        int contador = 1;
        while (contador <= 5) {
            System.out.println("Volta " + contador);
        }
    }
}

Falta o contador++. O contador fica em 1 para sempre, 1 <= 5 é sempre true, e o programa escreve "Volta 1" sem parar. No terminal da Ana, em dois segundos ele escreveu mais de meio milhão de linhas, até ela apertar Ctrl+C. Este é o fim da sessão:

$ java Main.java
Volta 1
Volta 1
Volta 1                      « … mais de 500 mil linhas iguais …
^CVolta 1                    « a Ana apertou Ctrl+C; o terminal mostra ^C
Volta 1                      « algumas linhas que já estavam a caminho
Volta 1
Volta 1
Volta 1
$ echo $?
130                          « 130 = programa interrompido pelo Ctrl+C

Como parar um programa preso

1. Clique na janela do terminal onde o programa está rodando.
2. Aperte Ctrl+C (segure Ctrl e toque em C). O terminal mostra ^C e o programa é encerrado.
3. O prompt ana@notebook:~/java$ volta. O código de saída, que você vê com echo $?, é 130: o jeito do Linux de dizer "interrompido pelo usuário".
4. Conserte o laço (quase sempre falta o passo, ou ele vai na direção errada) e rode de novo.

Nas IDEs (veja Editores e IDEs), o mesmo papel é do botão de parar, um quadrado vermelho perto do botão de rodar.

O laço infinito silencioso

Nem todo laço infinito enche a tela. Este aqui quer somar 1 + 2 + 3 + 4 + 5, mas também esqueceu o passo e não escreve nada dentro do laço:

public class Main {
    public static void main(String[] args) {
        int contador = 1;
        int soma = 0;
        while (contador <= 5) {
            soma = soma + contador;
        }
        System.out.println("Soma: " + soma);
    }
}

$ java Main.java
^C                           « nada aconteceu por 4 segundos; a Ana apertou Ctrl+C
$ echo $?
130

O programa parece "travado": nenhuma mensagem, nenhum erro, o cursor parado. Na verdade ele está trabalhando sem parar, somando 1 na variável soma milhões de vezes por segundo. Quando um programa "não faz nada e não termina", desconfie de um laço infinito.

public class Main {
    public static void main(String[] args) {
        int contador = 1;
        int soma = 0;
        while (contador <= 5) {
            soma = soma + contador;
        }
        System.out.println("Soma: " + soma);
    }
}

public class Main {
    public static void main(String[] args) {
        int contador = 1;
        int soma = 0;
        while (contador <= 5) {
            soma = soma + contador;
            contador++;
        }
        System.out.println("Soma: " + soma);
    }
}

Formas diferentes de repetir

Para a mesma tarefa (mostrar 1, 2 e 3) há várias formas. Elas dão a mesma saída; o que muda é a clareza.

Regra prática: sabe quantas vezes? Use for. Repete até algo acontecer? Use while. Precisa fazer uma vez antes de decidir? Use do-while.

Quando dá errado

public class Main {
    public static void main(String[] args) {
        int contador;
        while (contador <= 5) {
            System.out.println(contador);
            contador++;
        }
    }
}

$ java Main.java
Main.java:4: error: variable contador might not have been initialized
        while (contador <= 5) {
               ^
1 error
error: compilation failed

public class Main {
    public static void main(String[] args) {
        int contador = 1;
        do {
            System.out.println(contador);
            contador++;
        } while (contador <= 3)
    }
}

$ java Main.java
Main.java:7: error: ';' expected
        } while (contador <= 3)
                               ^
1 error
error: compilation failed

public class Main {
    public static void main(String[] args) {
        int contador = 1;
        while (contador <= 5); {
            System.out.println("Volta " + contador);
            contador++;
        }
        System.out.println("Fim!");
    }
}

$ java Main.java
^C                           « nenhuma "Volta"; a Ana teve que apertar Ctrl+C
$ echo $?
130

public class Main {
    public static void main(String[] args) {
        int contador = 1;
        while (false) {
            System.out.println(contador);
        }
    }
}

$ java Main.java
Main.java:4: error: unreachable statement
        while (false) {
                      ^
1 error
error: compilation failed

Referência

Exercícios

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        int idade;
        // escreva o do-while aqui

    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        int idade;
        do {
            System.out.print("Sua idade: ");
            idade = teclado.nextInt();
        } while (idade < 1 || idade > 120);
        System.out.println("Idade registrada: " + idade);
    }
}

Resumo

• Um laço repete um bloco de código. Cada repetição é uma iteração.
• while (condição) { … } testa a condição antes de cada volta; pode rodar 0 vezes.
• do { … } while (condição); testa depois; roda pelo menos 1 vez e termina com ;.
• Um contador tem três peças: início, condição e passo. Depois do laço, o contador vale o primeiro valor que fez a condição falhar.
• Se nada dentro do laço muda a condição, ele é infinito. Pare com Ctrl+C (código 130) e procure o passo que falta.
• Cuidado com o ; logo depois de while (…): vira um laço vazio e infinito.
• Para pedir um dado até ele ser válido, use do-while: pergunte primeiro, verifique depois.