Condições e laços em Java

Uma condição tem o tipo boolean: ela produz true ou false. Java precisa desse resultado explícito em uma condição de if ou de laço. Um inteiro sozinho não é uma condição, portanto while (count) não compila; count > 0 faz uma pergunta clara de resposta verdadeira ou falsa.

Compare números e caracteres

Com int a = 7; e int b = 10;, a < b e a != b são true, enquanto a >= b é false. Tipos numéricos diferentes podem ser comparados: 3 == 3.0 é true depois que Java faz uma conversão de ampliação do inteiro para double.

Uma comparação de char usa códigos numéricos Unicode. Por exemplo, 'a' < 'b' é true. O mesmo ocorre com 'Z' < 'a': seus códigos são 90 e 97. Nessa ordenação, todas as letras maiúsculas ASCII de A a Z precedem as minúsculas de a a z.

Armazene uma resposta útil

int age = 17;
boolean isAdult = age >= 18;
System.out.println(isAdult);

A comparação produz false, que é armazenado em isAdult e depois impresso. Um nome significativo permite que o código posterior diga diretamente if (isAdult).

Mantenha atribuição e comparação distintas. = armazena um valor; == compara valores. Para um inteiro, if (x = 5) falha porque a atribuição produz um inteiro. Para um booleano, if (done = true) compila, define done como true e executa o ramo. Para testar a variável sinalizadora existente, escreva if (done).

Compare texto e decimais calculados

Use command.equals("quit") para comparar os caracteres de uma cadeia de caracteres. O texto digitado como “quit” corresponde; “Quit” não corresponde. Use equalsIgnoreCase quando a diferença entre maiúsculas e minúsculas não importar e !command.equals("quit") para testar se o texto é diferente. O operador == verifica se as cadeias de caracteres se referem ao mesmo objeto, portanto não é adequado para comparar o conteúdo de uma entrada do usuário.

O formato binário de ponto flutuante não consegue armazenar muitas frações decimais exatamente. 0.1 + 0.2 produz 0.30000000000000004, portanto 0.1 + 0.2 == 0.3 é false. Uma comparação com tolerância verifica a distância entre os valores calculados:

double sum = 0.1 + 0.2;
boolean closeEnough = Math.abs(sum - 0.3) < 1e-9;

Aqui Math.abs torna a diferença não negativa; a pequena diferença está abaixo de 1e-9, portanto closeEnough é true. Escolha uma tolerância adequada à precisão exigida pelo cálculo. Comparações exatas de valores int não têm o problema de arredondamento em ponto flutuante.

Teste divisibilidade e intervalos

n % 3 == 0 testa se um inteiro é divisível por 3. Para números ímpares, use n % 2 != 0: o teste inclui valores ímpares negativos, pois -7 % 2 é -1.

Escreva cada lado de um teste de intervalo separadamente: 0 < x && x < 10. Java não consegue ler 0 < x < 10 como uma cadeia matemática: a primeira comparação já produz um booleano, que não pode ser comparado com 10.

Operadores lógicos combinam condições completas, verdadeiras ou falsas. Leia uma condição combinada como uma regra sobre os dados e depois teste valores que devem ser aceitos e valores que devem ser rejeitados.

Una e negue testes

&& significa e: ambas as partes devem ser verdadeiras. || significa ou: pelo menos uma parte deve ser verdadeira, inclusive quando ambas são. ! significa não e inverte um valor booleano.

| p | q | p && q | p || q | | --- | --- | --- | --- | | true | true | true | true | | true | false | false | true | | false | true | false | true | | false | false | false | false |

Uma temperatura confortável de 18 a 24 °C precisa dos dois limites: temp >= 18 && temp <= 24. Estar fora desse intervalo significa temp < 18 || temp > 24. Unir os limites internos com || aceita qualquer número: abaixo de 18, o teste do limite superior é verdadeiro e, acima de 24, o teste do limite inferior é verdadeiro.

Cada operando deve ser uma expressão booleana. Escreva x == 1 || x == 2, pois x == 1 || 2 coloca um inteiro onde um booleano é necessário. Para um inteiro, !x > 5 é inválido; !(x > 5) nega a comparação inteira.

Avalie apenas o necessário

Java avalia && e || da esquerda para a direita e usa a avaliação de curto-circuito quando a parte esquerda determina a resposta. Com &&, um lado esquerdo falso faz o lado direito ser ignorado. Com ||, um lado esquerdo verdadeiro faz o lado direito ser ignorado.

int total = 36;
int count = 0;
boolean largeAverage = count != 0 && total / count > 10;

A primeira comparação é falsa, portanto a divisão é ignorada e largeAverage passa a ser false. Inverta os operandos e a divisão ocorrerá antes da verificação de proteção; a divisão inteira por zero lança uma ArithmeticException. Coloque a verificação de segurança antes do cálculo que ela protege.

Torne o agrupamento visível

Da maior para a menor precedência, os operadores relevantes são !, comparações relacionais (<, <=, >, >=), comparações de igualdade (==, !=), && e depois ||. Assim, a || b && c é agrupado como a || (b && c). Quando a é verdadeiro e b e c são falsos, essa expressão é verdadeira; (a || b) && c é falsa. Os parênteses mostram qual regra você pretende usar.

As leis de De Morgan deslocam uma negação por uma condição combinada:

• !(p && q) equivale a !p || !q.
• !(p || q) equivale a !p && !q.

Negue cada parte e troque o operador que as une. Aplicar isso ao intervalo de temperatura mostra que !(temp >= 18 && temp <= 24) equivale a temp < 18 || temp > 24.

Expresse uma regra com uma exceção

Um ano bissexto no calendário gregoriano é divisível por 4, exceto que um ano de início de século deve ser divisível por 400:

boolean leap = (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;

A primeira parte aceita 2024. Ela rejeita 1900 porque 1900 é um ano de início de século; o teste final aceita 2000 porque ele é divisível por 400. O ano 2026 não atende a nenhuma das partes.

Booleanos com nomes ajudam a tornar testes mais longos claros, como isWeekend || isHoliday. Para dois booleanos, ^ é o OU exclusivo: exatamente um operando deve ser verdadeiro, como em !=. Os operadores simples & e | também calculam o e/ou booleano, mas avaliam ambos os operandos; use && e || para condições com curto-circuito.

Um if executa um bloco quando sua condição é verdadeira. Um if com else escolhe exatamente um de dois blocos. Depois que o bloco escolhido termina, a execução continua com a instrução seguinte.

Escolha um caminho

int age = 16;
if (age >= 18) {
    System.out.println("Adult ticket");
} else {
    System.out.println("Youth ticket");
}
System.out.println("Next customer");

A condição é falsa, portanto a saída é “Youth ticket”, seguida de “Next customer”. A última instrução não pertence a nenhum dos ramos. Coloque a condição booleana entre parênteses e as instruções de cada ramo entre chaves.

Sem chaves, apenas a próxima instrução pertence a um if. A indentação não agrupa código. Neste exemplo com erro, a segunda mensagem aparece para qualquer pontuação:

if (score < 50)
    System.out.println("Not passed");
    System.out.println("Try again");

Chaves ao redor das duas instruções de impressão tornam ambas condicionais. Outro erro é um ponto e vírgula imediatamente após a condição: if (x > 10); tem um corpo vazio. Um bloco que venha em seguida é executado independentemente, e um else depois desse bloco independente não tem um if correspondente.

Mantenha um resultado disponível

Uma variável declarada dentro de um bloco só é visível dentro dele. Declare um resultado antes dos ramos quando o código posterior precisar dele:

String ticket;
if (age >= 18) {
    ticket = "Adult ticket";
} else {
    ticket = "Youth ticket";
}
System.out.println(ticket);

Ambos os caminhos possíveis atribuem um valor a ticket, portanto imprimi-la depois é válido. Se apenas o ramo verdadeiro atribuísse um valor a ela, Java rejeitaria a leitura posterior: a variável poderia não ter sido inicializada. Declarar ticket separadamente dentro de cada ramo também deixaria ticket indisponível depois da decisão.

Coloque uma decisão dentro de outra

Um if aninhado só executa seu teste quando a execução chega ao ramo que o contém:

if (hasTicket) {
    if (age < 12) {
        System.out.println("Child seat");
    } else {
        System.out.println("Standard seat");
    }
} else {
    System.out.println("Buy a ticket first");
}

Uma pessoa sem ingresso chega ao else externo; a verificação de idade é ignorada. Se ambos os testes aninhados apenas condicionam a mesma ação e nenhum deles tem else, eles podem se tornar if (hasTicket && age < 12).

A regra do else pendente associa um else ao if mais próximo ainda sem correspondência. Sem chaves, alinhá-lo visualmente com um if externo não altera essa regra. Para um teste externo de x positivo seguido de um teste interno de y positivo, o próximo else pertence ao teste de y. São necessárias chaves ao redor da decisão interna completa quando o else deve pertencer ao teste externo.

Escolha um valor com ?:

O operador condicional escolhe um de dois valores:

int n = 7;
String label = n % 2 == 0 ? "even" : "odd";

A condição é falsa, portanto a expressão produz “odd”. Sua forma é condition ? valueIfTrue : valueIfFalse. Use-o para uma escolha curta de valor; use um if quando os ramos executarem várias ações. Expressões condicionais aninhadas logo tornam difícil acompanhar o caminho escolhido.

Uma cadeia de else if testa condições em ordem e seleciona a primeira verdadeira. Depois que esse ramo é executado, as condições restantes são ignoradas. Um else final trata os valores restantes; sem ele, a cadeia pode não executar nenhuma ação.

Ordene limiares sobrepostos

Para pontuações de 0 a 100, teste primeiro a nota mais alta:

String grade;
if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else if (score >= 60) {
    grade = "D";
} else {
    grade = "F";
}

Para 85, o primeiro teste falha e o segundo é satisfeito. O programa atribui “B” sem verificar os limiares restantes. Chegar a score >= 80 já significa que a pontuação é menor que 90, portanto um limite superior adicional é desnecessário.

Se score >= 60 aparecesse primeiro, toda pontuação de aprovação receberia “D”. Trabalhe do caso correspondente mais restritivo para os mais abrangentes. Essa regra de ordenação importa porque várias condições podem ser verdadeiras, embora apenas um ramo seja executado.

Trate primeiro o caso combinado

FizzBuzz tem um caso especial em que duas regras se sobrepõem: múltiplos de 3 e de 5 precisam de “FizzBuzz”. Teste esse caso antes de qualquer um dos testes individuais de divisibilidade:

if (n % 15 == 0) {
    System.out.println("FizzBuzz");
} else if (n % 3 == 0) {
    System.out.println("Fizz");
} else if (n % 5 == 0) {
    System.out.println("Buzz");
} else {
    System.out.println(n);
}

O teste % 15 == 0 aceita 30; 9 chega a “Fizz”, 10 chega a “Buzz” e 7 chega ao ramo final. Começar com % 3 == 0 aceitaria 30 cedo demais e imprimiria apenas “Fizz”.

Escolha um resultado ou várias ações

Instruções if separadas são decisões independentes. Com x = 15, um if (x > 10) pode imprimir “big” e um if (x > 0) seguinte também pode imprimir “positive”. Uni-los com else if torna o segundo teste inalcançável sempre que o primeiro for verdadeiro. Use testes independentes quando ambas as ações puderem ser necessárias; use uma cadeia para selecionar um resultado.

Verifique limites e valores inválidos

Uma cadeia para temperaturas inteiras com temp < 10, depois temp > 10 && temp < 25 e depois temp >= 25 deixa de fora exatamente 10. Substitua o segundo teste por temp < 25: chegar a ele já significa que o primeiro teste falhou, portanto o valor é pelo menos 10. Um else final trata então 25 e valores maiores.

Para cada limiar, experimente o valor imediatamente abaixo dele, o próprio limiar e o valor imediatamente acima dele. Para a cadeia de notas, 89, 90 e 91 revelam se o limite de A está incluído corretamente. Teste também os limites gerais.

Valide uma pontuação antes de atribuir uma nota: coloque score < 0 || score > 100 primeiro e informe “Invalid score” nesse caso. Os ramos posteriores operam então apenas sobre pontuações válidas; 150 não pode receber “A” acidentalmente. A validação é um primeiro caso separado, não uma correção depois que a nota já foi escolhida.

Um switch seleciona um caso comparando um valor com rótulos fixos. Ele é adequado para comandos nomeados e escolhas numeradas. Use uma cadeia de else if quando a escolha depender de um intervalo ou de várias variáveis.

Encontre valores exatos

Um switch por valor aceita seletores char, byte, short, int, seus tipos empacotadores, String e tipos enum. Sem recursos em prévia, seletores long, float, double e boolean não são aceitos. Os rótulos devem ser constantes: uma condição como score >= 90 não é um rótulo de valor.

switch (day) {
    case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
    case 6, 7 -> System.out.println("Weekend");
    default -> System.out.println("Invalid day");
}

Um caso com seta executa apenas seu próprio código, sem continuação para o caso seguinte. Vírgulas agrupam vários rótulos para uma ação. Um dia igual a 6 imprime “Weekend”; um dia igual a 9 não corresponde a nenhum valor listado e imprime “Invalid day”.

Rótulos de String correspondem a conteúdos exatos, com distinção entre maiúsculas e minúsculas. Um comando “Start” não corresponde a case "start". Um rótulo duplicado é um erro de compilação, e um mesmo switch não pode misturar casos com seta e casos com dois-pontos.

Produza um valor

Uma expressão switch calcula um resultado:

int days = switch (month) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11 -> 30;
    case 2 -> 28;
    default -> 0;
};

Em um ano não bissexto, o mês 9 produz 30, o mês 2 produz 28 e o mês inválido 13 produz 0. O ponto e vírgula após a chave de fechamento encerra a declaração da variável.

Uma expressão deve ser exaustiva: cada valor possível do seletor deve ter um resultado. Para estes exemplos com int e String, inclua default. Uma instrução switch por valor pode omitir default; nesse caso, um valor sem correspondência não executa nenhum caso. Uma expressão que produz um valor não pode simplesmente deixar de produzir seu resultado.

Forneça um resultado a um bloco com yield

Um caso que faz cálculos antes de escolher seu valor precisa de um bloco:

int days = switch (month) {
    case 2 -> {
        boolean leap = (year % 4 == 0 && year % 100 != 0)
                || year % 400 == 0;
        yield leap ? 29 : 28;
    }
    case 4, 6, 9, 11 -> 30;
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    default -> 0;
};

yield fornece o valor do caso à expressão switch. Fevereiro produz 29 em 2024 e 28 em 2026. Uma única expressão após uma seta, como case 2 -> 28;, não precisa de yield.

Leia a forma mais antiga com dois-pontos

switch (level) {
    case 1:
        System.out.println("Bronze");
    case 2:
        System.out.println("Silver");
        break;
    case 3:
        System.out.println("Gold");
        break;
}

Para o nível 1, a execução entra no primeiro caso e continua no segundo, imprimindo tanto “Bronze” quanto “Silver”. Isso é a continuação entre casos: um rótulo com dois-pontos não interrompe a execução. break encerra o switch. Rótulos com dois-pontos em sequência podem compartilhar uma ação deliberadamente; a falta de um break após uma ação pode executar a próxima acidentalmente.

Um switch de char pode agrupar 'a', 'e', 'i', 'o', 'u' em um resultado “vowel”, com default produzindo “other”. O mesmo princípio de valor exato se aplica a caracteres, comandos e escolhas numéricas.

Um laço while testa sua condição antes de cada passagem. Se a condição for verdadeira, Java executa o corpo e retorna ao teste. Se for falsa, a execução continua depois do laço. Um primeiro teste falso significa zero passagens.

Acompanhe início, teste, corpo e atualização

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

O valor inicial é 1. Cada passagem imprime o valor atual e depois o incrementa. A quinta passagem imprime 5 e altera i para 6. O teste seguinte é falso, portanto o laço termina. Há cinco execuções do corpo, mas seis testes da condição: um antes de cada passagem e um teste falso final.

Um laço de contagem precisa de um valor inicial, um teste e uma atualização que o aproxime da parada. Omita i++ e esse laço imprimirá 1 para sempre. Um ponto e vírgula indevido é outra armadilha: em while (i <= 5);, a instrução vazia é o corpo. Quando i começa dentro do intervalo, o bloco posterior nunca é alcançado e não pode atualizá-lo.

Pare quando um limite for ultrapassado

A igualdade costuma ser um teste de parada frágil. Começar em 0 e somar 3 passa por 0, 3, 6, 9, 12 e assim por diante. O teste i != 10 não consegue perceber que 10 foi ultrapassado, pois 10 é pulado. O teste i < 10 termina depois de processar 9. Escolha um limite que corresponda à direção da atualização.

Alguns laços se repetem um número desconhecido de vezes. Por exemplo:

int amount = 1;
int days = 0;
while (amount < 1000) {
    amount *= 2;
    days++;
}

Cada passagem dobra a quantidade e conta um dia. Após nove passagens, ela é 512; após dez, é 1024. O teste falso em 1024 deixa days igual a 10. Um laço pode terminar acima de seu limiar quando a atualização avança em passos maiores.

Leia antes de decidir se deve parar

while (true) {
    String line = scanner.nextLine();
    if (line.equals("stop")) {
        break;
    }
    System.out.println("You wrote: " + line);
}

Aqui scanner é o Scanner de entrada. O laço lê uma linha, verifica se é “stop” e exibe apenas as linhas comuns. O comando de parada é lido, mas não é processado. while (true) precisa de uma saída alcançável para terminar; um laço que continua se repetindo sem sair é um laço infinito.

Registre as alterações de estado

Considere um produto:

int n = 3;
int product = 1;
while (n > 0) {
    product *= n;
    n--;
}

A multiplicação usa o valor anterior de n, e o decremento vem depois. Mover o decremento para antes da multiplicação alteraria os valores multiplicados.

Declare um resultado acumulado antes do laço para que ele seja mantido de uma passagem para outra. Uma variável declarada dentro do corpo é criada novamente sempre que a execução chega à sua declaração. Imprima dentro do corpo para ver os resultados intermediários; imprima após a chave de fechamento para mostrar o resultado final uma vez.

Um laço do-while executa o corpo antes de verificar se outra passagem é necessária. Use-o quando a primeira ação precisar acontecer, como mostrar um menu ou pedir um valor de entrada.

Teste após a primeira ação

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

O corpo imprime 10 e incrementa i para 11. Só então Java testa i < 5. A condição é falsa, portanto não há uma segunda passagem. Um laço while (i < 5) que começasse em 10 não imprimiria nada.

O ponto e vírgula após o while (...) final é obrigatório. Ele encerra a instrução do-while. Isso é diferente do ponto e vírgula acidental após um cabeçalho while com teste no início, que cria um corpo de laço vazio.

Repita enquanto a entrada for inválida

int rating;
do {
    System.out.print("Rating (1-5): ");
    rating = Integer.valueOf(scanner.nextLine());
} while (rating < 1 || rating > 5);

A solicitação aparece antes da primeira verificação, para que o usuário possa fornecer o valor a ser verificado. Com as entradas 7, depois 0 e depois 4, as duas primeiras avaliações da condição são verdadeiras e provocam outra solicitação. A última é falsa, portanto o laço termina com rating igual a 4.

A condição descreve a continuação, não a aceitação. Uma avaliação válida satisfaz rating >= 1 && rating <= 5. O laço se repete enquanto essa afirmação é falsa, o que as leis de De Morgan reescrevem como rating < 1 || rating > 5. Uma conjunção entre esses limites externos nunca seria verdadeira: um número não pode estar abaixo de 1 e acima de 5 ao mesmo tempo.

Declare a variável verificada antes do bloco

A chave de fechamento encerra o escopo do corpo antes que a condição seja avaliada. Uma declaração como int rating dentro do bloco do ficaria, portanto, indisponível na condição final. Declare-a antes de do e atribua a entrada dentro do corpo. A atribuição sempre é executada antes do primeiro teste.

A mesma posição importa quando o valor aceito é usado depois. rating permanece no escopo após todo o laço e agora contém o último valor lido.

Mantenha um menu aberto

String choice;
do {
    System.out.println("a: show status, q: quit");
    choice = scanner.nextLine();
    if (choice.equals("a")) {
        System.out.println("Ready");
    }
} while (!choice.equals("q"));

Cada passagem exibe o menu e lê uma escolha. Digitar “a” imprime “Ready” e repete. Digitar “q” pula a ação e encerra o laço na condição. Um comando desconhecido também provoca repetição porque não é “q”.

Quando seu corpo não contém um continue direcionado ao laço, um do-while pode ser reescrito como while (true) com um break no final que verifica a condição negada. Um continue exige cuidado especial nessa reescrita: no do-while original, ele salta para a condição, enquanto em um laço while-true ele salta para o início e pode pular esse teste acrescentado ao final.

Um laço for reúne o controle de uma tarefa de contagem em um cabeçalho. Ele é útil quando você conhece o intervalo ou o número de passagens antes do início da repetição.

Leia o cabeçalho na ordem de execução

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

A inicialização é executada uma vez, definindo i como 1. Java testa i <= 5, executa o corpo se a condição for verdadeira, executa i++ e volta ao teste. A atualização é escrita no cabeçalho, mas é executada depois do corpo. O teste falso final encerra o laço.

Para uma contagem comum, i++ e ++i têm o mesmo efeito na posição de atualização porque o valor de nenhuma das expressões é usado. Mantenha as alterações do contador no cabeçalho para que a sequência seja fácil de prever.

Escolha o primeiro e o último valor

Para passos crescentes de uma unidade com o final pelo menos igual ao início, um limite final exclusivo produz final menos início passagens; um limite final inclusivo acrescenta uma. Passos maiores exigem listar ou contar os valores efetivamente alcançados. Um laço decrescente deve testar na direção correspondente: começar em 10 com i <= 1 produz zero passagens.

Um erro de uma unidade inclui ou exclui um limite indevidamente. Para imprimir de 1 a 10, i < 10 deixa 10 de fora; use i <= 10. Verifique o primeiro valor do corpo, o último valor do corpo e o primeiro valor que não satisfaz a condição.

Construa um resultado ao longo de um intervalo

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

O corpo soma cada inteiro uma vez, terminando com 5050. Um produto começa de forma diferente: inicialize product em 1 antes de multiplicar por 1 a 5. Isso produz 120; começar em 0 manteria o produto em 0 após cada multiplicação.

Observe o escopo e os corpos vazios

Um contador declarado no cabeçalho existe durante todo o laço, mas não depois de sua chave de fechamento. Declare-o antes se o código posterior precisar de seu valor final.

Um ponto e vírgula imediatamente após o cabeçalho é um corpo vazio. Em for (int i = 0; i < 3; i++);, a instrução vazia é executada três vezes. Um bloco seguinte que imprime “Hello” é executado uma vez depois do laço, não três. As chaves devem vir diretamente após o cabeçalho.

Qualquer parte do cabeçalho pode ser omitida. for (;;) { ... } não tem condição de parada e se comporta como while (true); ele precisa de uma saída como break para terminar.

Selecione o laço mais claro

As formas podem expressar a mesma repetição, mas as reescritas devem preservar a ordem dos testes e das atualizações, incluindo o que um continue pula.

Uma saída antecipada pode interromper a repetição assim que sua tarefa estiver concluída. Uma passagem pulada pode deixar de executar um trabalho indesejado enquanto mantém o laço em andamento. Acompanhe seus destinos com cuidado: break e continue têm funções diferentes.

Encerre uma busca com break

for (int n = 51; n <= 100; n++) {
    if (n % 7 == 0) {
        System.out.println(n);
        break;
    }
}

Os valores de 51 a 55 não passam no teste de divisibilidade. O próximo valor, 56, é impresso e break sai do laço imediatamente. A atualização não é executada após esse break. Sem ele, múltiplos posteriores como 63 e 70 também seriam impressos.

Um break sem rótulo se aplica ao laço ou switch mais próximo que o contém. A execução continua depois dessa estrutura, não depois do programa inteiro.

Pule com continue

for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        continue;
    }
    System.out.print(i + " ");
}

Para 3, 6 e 9, continue pula a instrução de impressão. Em um laço for, a atualização do cabeçalho ainda é executada, seguida do teste da condição. A saída contém 1, 2, 4, 5, 7, 8 e 10.

Em um while ou do-while, continue vai para a condição. Qualquer atualização abaixo dele no corpo é pulada. Se um contador de while começar em 0 e a primeira ação for if (i % 3 == 0) { continue; }, um i++ posterior no corpo nunca será alcançado. O contador permanece em 0 e o laço se repete para sempre. Mova a atualização necessária para antes de cada caminho que a pula ou use um cabeçalho for para manter a atualização automática.

Saia de laços aninhados deliberadamente

Um break comum dentro de um laço interno encerra apenas esse laço interno. Um rótulo pode indicar um laço externo como destino da saída:

outer:
for (int a = 1; a <= 10; a++) {
    for (int b = 1; b <= 10; b++) {
        if (a * b == 24 && a + b == 10) {
            System.out.println("Found " + a + " and " + b);
            break outer;
        }
    }
}

A busca percorre os pares em ordem. Em a = 4 e b = 6, ambos os testes são satisfeitos e o break com rótulo sai dos dois laços. continue outer seguiria para a atualização do laço externo e depois para seu próximo teste.

Distinga saídas de switch de saídas de laço

Em um laço de menu que contém um switch na forma com dois-pontos, break dentro de um caso encerra o switch. Ele não encerra por si só o laço ao redor. Um padrão claro define uma variável sinalizadora do laço como false no caso de saída e depois usa break para sair do switch. O laço termina quando sua próxima verificação da condição encontra a variável sinalizadora falsa. Casos com seta não precisam de break para impedir a continuação entre casos.

Break sem rótulo é permitido dentro de um laço ou switch; continue é permitido dentro de um laço. Colocá-los em outro lugar causa falha de compilação. Mantenha a regra normal de parada na condição do laço quando ela couber ali. Use while (true) com um break quando o teste de parada naturalmente pertencer a um ponto depois da leitura da entrada, mas antes de seu processamento. Várias saídas podem ser úteis, mas cada caminho adicional acrescenta estado a acompanhar durante o rastreamento.

Um contador registra quantos valores atendem a uma condição. Um acumulador combina valores em um resultado acumulado. Declare ambos antes do laço para que cada passagem continue o trabalho anterior.

Inicialize conforme a operação

Use int count = 0; e incremente quando um item atender à condição. Uma soma começa em 0 e usa sum += value;. Um produto começa em 1, pois multiplicar um 0 inicial eliminaria todos os fatores posteriores. Inicializar um total dentro do corpo o reinicia a cada passagem.

Para um intervalo, o passo do laço pode selecionar os valores: somar os inteiros pares de 2 a 100 em passos de 2 produz 2550. Ou coloque uma condição dentro do laço. Contar os números de 1 a 100 divisíveis por 3 ou por 5 produz 47: os seis múltiplos de 15 devem ser contados apenas uma vez.

Interrompa a entrada antes de somá-la

Uma sentinela é um valor especial de entrada que encerra a leitura. Ela não é um valor comum dos dados:

int sum = 0;
int count = 0;
while (true) {
    int number = Integer.valueOf(scanner.nextLine());
    if (number == 0) {
        break;
    }
    sum += number;
    count++;
}

Para a entrada 12, 7, 5, 0, a soma passa por 12, 19 e 24. A contagem chega a 3. O 0 final aciona o break antes que qualquer uma das variáveis mude. Contá-lo criaria um quarto item e produziria uma média incorreta, embora somar zero não altere a soma.

Divida somente após verificar a contagem

if (count > 0) {
    double average = (double) sum / count;
    System.out.println(average);
} else {
    System.out.println("No numbers entered");
}

O exemplo imprime 8.0. Com operandos inteiros, a divisão descarta a parte fracionária: 25 / 4 é 6. Converta antes de dividir para obter 6,25: (double) sum / count. Fazer a conversão explícita depois, (double) (sum / count), apenas converte o resultado já truncado para 6,0.

Se a sentinela chegar primeiro, a contagem será 0. A divisão inteira por zero lança uma ArithmeticException; uma soma em ponto flutuante igual a zero dividida por zero produz NaN. A verificação da contagem impede que uma entrada vazia produza uma média sem sentido.

Acompanhe vários resultados em uma passagem

Para as pontuações 55, 72, 90, 48 e 81, uma nota mínima de 60 produz cinco pontuações e três aprovações. Mantenha um contador total para cada pontuação e um contador de aprovações dentro da condição de aprovação. 100.0 * passed / total produz 60,0 por cento; 100.0 faz a aritmética usar ponto flutuante. Verifique também se o total é positivo antes dessa divisão.

O local da impressão muda o que é mostrado. Distâncias de 5, 3 e 8 km produzem totais acumulados de 5, 8 e 16 km quando impressos dentro do laço após a adição. Imprimir depois mostra apenas os 16 km finais.

Escolha um tipo grande o suficiente para o total

O máximo de int é 2.147.483.647. Somar todos os inteiros de 1 a 100.000 deve produzir 5.000.050.000, mas um int retorna ao valor 705.082.704 sem informar um erro. long sum = 0; armazena essa soma corretamente; o máximo de long é cerca de 9,2 × 10¹⁸. Fazer uma conversão de ampliação depois de o resultado já ter sofrido estouro não pode recuperar o valor perdido.

Alguns laços guardam um melhor valor; outros guardam se uma correspondência ocorreu. Escolha o estado inicial de modo que ele represente a situação corretamente antes e depois de cada passagem.

Mantenha o melhor valor encontrado até o momento

Para acompanhar um máximo, substitua-o somente quando o valor atual for maior: if (value > max) { max = value; }. Começando pela primeira leitura, as temperaturas 14, 19, 11, 23 e 17 °C deixam máximos sucessivos de 14, 19, 19, 23 e 23 °C. Um mínimo usa <.

Inicializar um máximo em 0 falha com dados totalmente negativos: -5, -2 e -9 deixariam incorretamente 0 como resultado. Inicialize a partir de uma leitura real ou comece com Integer.MIN_VALUE para um máximo int e Integer.MAX_VALUE para um mínimo int. Informe que não há resultado quando não houver leituras.

Para registrar uma posição, atualize-a no mesmo ramo que o valor. Um > estrito mantém o primeiro máximo em caso de empate; >= o substitui novamente e mantém o último.

Pare após encontrar uma correspondência

int n = 1;
while (n * n <= 500) {
    n++;
}

Em 22, o quadrado é 484, portanto outra passagem é executada. Em 23, ele é 529 e a condição falha. O laço encontrou o menor inteiro positivo cujo quadrado é maior que 500. Uma busca com limites pode, em vez disso, testar cada candidato em um laço for e usar break na primeira correspondência.

Para uma pergunta com algum, comece com uma variável sinalizadora falsa e torne-a verdadeira ao encontrar uma correspondência. Para uma pergunta com todos, comece com ela verdadeira e torne-a falsa ao encontrar um contraexemplo. Não reinicie nenhuma das duas em um ramo else para valores posteriores: uma leitura posterior sem correspondência não apaga, por exemplo, uma leitura negativa anterior.

Teste se há um divisor

Um número primo é pelo menos 2 e não tem divisor de 2 até uma unidade a menos que ele mesmo. Para um inteiro positivo pequeno, uma verificação mais curta testa divisores apenas até sua raiz quadrada:

int n = 91;
boolean isPrime = n >= 2;
for (int d = 2; d * d <= n; d++) {
    if (n % d == 0) {
        isPrime = false;
        break;
    }
}

Os dois fatores de um par não podem ser ambos maiores que a raiz quadrada. Para 91, o divisor 7 produz resto zero e muda a variável sinalizadora para falsa. Para 97, nenhum divisor de 2 a 9 o divide, portanto a variável sinalizadora permanece verdadeira. Valores abaixo de 2 começam com a variável sinalizadora falsa. Para valores int positivos grandes, use d <= n / d para evitar estouro em d * d.

Remova um algarismo decimal por passagem

Para um inteiro não negativo, % 10 extrai o último algarismo e a divisão inteira / 10 o remove:

int n = 4072;
int sum = 0;
while (n > 0) {
    sum += n % 10;
    n /= 10;
}

Os algarismos são 2, 7, 0 e 4, produzindo 13. A variável de trabalho n termina em 0. Para inverter os algarismos, atualize reversed = reversed * 10 + n % 10; antes de remover o algarismo; 1234 se torna 4321 quando o resultado cabe no tipo escolhido.

Para contar algarismos, zero precisa de uma passagem mesmo que n > 0 comece falso. Use um do-while que incremente a contagem e divida n por 10. Ele conta um algarismo para 0 e a quantidade habitual para valores positivos.

Laços aninhados repetem uma repetição inteira a cada passagem externa. Eles são úteis para linhas, colunas, tabelas e formas. O laço interno deve começar novamente sempre que o laço externo chegar a ele.

Imprima uma linha e depois encerre-a

for (int row = 1; row <= 3; row++) {
    for (int col = 1; col <= 5; col++) {
        System.out.print(row * col + "\t");
    }
    System.out.println();
}

A primeira linha contém 1, 2, 3, 4, 5; a segunda contém 2, 4, 6, 8, 10; a terceira contém 3, 6, 9, 12, 15. O print interno cria colunas em uma linha; o println após o laço interno encerra essa linha. Mover println para dentro do laço interno coloca cada produto em uma linha própria.

Com contagens fixas, multiplique as passagens externas pelas internas. Três passagens externas e quatro passagens internas executam o corpo interno 12 vezes. A tabela acima tem três vezes cinco, ou 15, impressões de produtos.

Permita que o tamanho da linha mude

for (int row = 1; row <= 4; row++) {
    for (int col = 1; col <= row; col++) {
        System.out.print("*");
    }
    System.out.println();
}

O limite interno agora depende da linha. Suas contagens são 1, 2, 3 e 4, portanto o triângulo contém 10 asteriscos. Uma única multiplicação de contagens fixas estaria errada porque o laço interno não é executado o mesmo número de vezes em cada linha.

Use nomes diferentes para contadores de laços cujos escopos se sobrepõem. Declarar outro int i dentro de um laço em que i já está no escopo causa falha de compilação. Para um laço while interno, inicialize seu contador no início de cada passagem externa. Inicializá-lo apenas antes do laço externo o deixa além do limite após a primeira linha.

Rastreie valores em um ponto consistente

Para um laço de 1 a 4, subtraia valores ímpares de um total que começa em 0 e some os pares:

Registre se uma linha descreve o início ou o fim de uma passagem. Inclua a condição final falsa ao verificar o término. Um rastreamento que misture valores de antes e de depois da atualização pode fazer um laço correto parecer errado.

Coloque separadores entre itens

Cinco números precisam de quatro vírgulas. Imprima um separador antes de cada item, exceto o primeiro:

for (int i = 1; i <= 5; i++) {
    if (i > 1) {
        System.out.print(", ");
    }
    System.out.print(i);
}

A saída é “1, 2, 3, 4, 5”, sem vírgula no início ou no fim. Esse é um problema dos postes de cerca: o número de espaços entre itens é diferente do número de itens.

Teste casos que revelam erros

Experimente zero passagens, uma passagem e os valores em cada limite e próximos a ele. Para laços de entrada, experimente a sentinela primeiro. Para laços aninhados, verifique se a segunda linha reinicia corretamente. Impressões temporárias das variáveis de controle do laço revelam o progresso real. Se um programa travar, examine cada caminho em busca de uma atualização ou saída e interrompa-o com Ctrl+C em um terminal ou com o botão de parada do ambiente de desenvolvimento.