Certificação Java SE 7 Programmer I: Laços

Crie e use laços do tipo while - Laços do tipo while

Nesta seção veremos como funciona a construção de loops, de laços, usando o while. Vamos lá. Temos que saber criar e usar laços com o while.

Primeira coisa, vou criar agora New File, Testawhile.java, e dentro do Testawhile.Java eu vou ter a minha classe Testawhile.

Aqui dentro da minha classe Testawhile eu vou escrever um primeiro laço. O meu laço vai fazer, criar uma variável int i = 1;, e eu vou fazer um while(i < 10) {, System.out.println(i);, e vou rodar. Entrou em loop infinito.

Primeira coisa do while é que ele pode fazer um loop infinito. Segunda coisa do while, e se eu quiser parar? Então vou fazer aqui um i++, aumentar o valor do i. Compilo e rodo. 1, 2, 3, 4, 5, 6, 7, 8, 9. Por que ele parou no 9? Repara, no while, primeiro, olha esse código aqui, e olha o que acontece na memória. i = 1, criamos uma variável i = 1. Depois entramos no laço, entramos na linha dois, agora no while, i < 10, sim ou não? Sim.

A primeira coisa que o while faz é, em valor, verificar o valor da expressão, pegar o valor da expressão. i é menor do que 10? Sim ou não? Essa expressão tem que ser booleana, e ele verificou essa expressão booleana é true ou é false. Primeira coisa que o while faz é verificar ela. A condição é true, então ele continua lá dentro.

Aí ele executa, imprime o valor um, soma vira dois, e aí quando ele termina um laço, ele volta para o while para executar a condição de novo. i é menor do que 10? Sim, então ele continua lá dentro. Ele faz isso por três, por quatro, por cinco, por seis, por sete, por oito, por 9.

Quando ele faz i++ e passa a valer nove, ele volta para verificar a condição. Quando ele volta para verificar a condição, o while (i < 10), i é menor do que 10, sim, agora ele entra pela última vez no nosso laço. System.out.println 9, i++, i passou a valer 10, e aí ele volta para o while. O while, i é menor do que 10? 10 não é menor do que 10, aí ele cai fora.

Duas coisas importantes do while, primeira, por enquanto, é, que ele pode entrar em loop infinito se eu não tomar cuidado, e a segunda é, que ele, primeiro, verifica condição. Então, nesse caso, ele imprime de 1 até 9.

Se ele primeiro verifica a condição, quer dizer que se o meu valor de i fosse grande o suficiente, por exemplo, 11, a primeira coisa que ele ia verificar é a condição. Se ele verifica a condição, e a condição for false, logo de cara, ele nem entra, nem executa o meu while. Vamos testar.

Compilo, rodo, não imprime nada, porque logo de cara ele fez o evaluation, ele pegou aquela nossa expressão e evaluou, e rodou, para ver qual era o resultado; o resultado era false, ele caiu fora, nem entrou no laço. Esse é um ponto importante do while.

Voltei atrás e coloquei o valor 1. O while é separado por uma condição e o código. O código, se ele é feito dessa maneira em uma única linha, eu posso tirar as chaves, e se eu tirar as chaves, então quer dizer que só a próxima linha será executada dentro do while. Vamos testar esse código. Eu venho aqui, compilo e rodo. 1, 2, 3, 4, 5, 6, 7, 8, 9. Maravilha.

Cuidado com a famosa pegadinha das chaves, se eu não tenho chaves, mas eu tenho a indentação aqui, eu posso ser sacana e colocar na próxima linha também indentado o i++, mas no Java a indentação não vai fazer diferença para nós, o que importa é que não tem chaves. Se não tem chaves, esse é o código dentro do while, e esse é o código fora do while.

Vamos testar. Compilo e rodo. Um infinito. Toma bastante cuidado com a questão do looping infinito, toma bastante cuidado com a questão das chaves, se não tem chaves só vai executar a primeira expressão.

O compilador pode ser um pouquinho esperto, se a condição de loop infinito é explícita, por exemplo, se eu colocar aqui o while(true), ele sabe que isso daqui vai ser executado eternamente. Se isso é executado eternamente, quando essa linha será executada? Nunca. Ela nunca será executada, e o compilador percebe isso.

Se eu escrever um while(true), o compilador percebe que o i++ nunca será executado. Vamos compilar. Eu tento compilar e ele fala: "Essa linha nunca será executada, a gente nunca vai chegar nessa linha".

Então, se tem um while(true) que nunca é quebrado, isto é, é uma condição eterna de verdadeiro, e nunca a quebraremos, porque só tem o System.out.println(i); aqui, nunca vai quebrar dela. Então, ele vai falar: "Nunca chegará nessa linha" e não deixa compilar, porque você errou, tem algum código aqui que não era para estar". O compilador percebe isso.

Mesmo que eu faça uma condição, por exemplo, while(verdadeiro), e eu coloco aqui boolean verdadeiro = true;, se eu colocar o final aqui, ele vai perceber que essa variável é final boolean verdadeiro = true; e nunca vai chegar naquela linha.

Eu tento compilar e ele fala a mesma coisa. Se eu tirar o final, aí não, aí ele não tem como detectar. Pode ser que o código que você escreveu aqui faça alguma loucura que muda essa variável para false algum dia, não sei como, mas pode ser. Então, como pode ser, ele não percebe isso, o compilador. Então, nesse caso ele vai entrar em looping infinito de novo. Vamos tentar. E ele entra em looping infinito.

Tome bastante cuidado com o looping infinito, bastante cuidado com as chaves para executar uma única expressão, ou várias expressões, e bastante cuidado que, se você tem uma variável final, uma condição final booleana true, ele vai perceber que aquilo é infinito, ou um while true direto.

E se eu colocar um while false. Simplesmente execute isso daqui somente se false. Eu tento compilar e aí ele fala o inverso: "Isso daqui você nunca terá executado". Então, um while falso, também é inteligente e ele percebe, nunca será executado, tem alguma coisa de errado no seu código, não compila.

Então, cuidados que temos que tomar com o while são: Primeiro ele executa a condição, depois o código; ele pode entrar em looping infinito; as chaves são opcionais, se você não colocar ele só executa uma expressão; se o while é true, ou é uma variável booleana que implica em true eterno, e não tem nenhuma condição de quebra lá dentro, um break, alguma coisa do gênero, ele vai falar que se você tiver algum código ali embaixo depois do while, não compila, porque nunca chegará lá.

E pelo contrário, se for false, eternamente false, ele percebe que essa variável é false, nunca vai entrar nesse looping, não compila, porque você escreveu código lá que nunca será executado.

Crie e use laços do tipo for, incluindo o enhanced for - Laços do tipo for

Nesta seção veremos como trabalhar com o for, tanto o for tradicional, com três pedaços, quanto o enhanced for, o foreach que chamamos no Java.

Então, criar e utilizar laços do tipo for, tanto o tradicional, quanto o enhanced for. Vou criar uma classe. Esse arquivo vai chamar TestaFor, public class TestaFor {. public static void main(String[] args) {.

Primeiro ponto é por que o for acaba existindo? É porque o clássico, o uso clássico do while é criar uma variável. Um uso clássico. Primeiro ponto é por que existe o for tradicional? É que um dos usos clássicos de laço é criar uma variável e fazer algo enquanto essa variável não atinge determinado valor. Então você faz algo aqui dentro.

Por exemplo, imprime o valor de i. int i = 1;. while(i < 10) {. System.out.println(i);. Esse caso, repara que ele é composto por três partes, a criação e inicialização de uma variável, junto com a condição de parada e um incremento, um código que é executado a cada vez que o nosso laço é executado. Após a execução do laço, antes da condição ser verificada novamente.

Isso é, primeiro passo, inicializa variável uma única vez; depois verifica a condição, executa o loop, executa o incremento; verifica a condição e executa o loop, executa o incremento; verifica a condição, executa o loop, executa o incremento. Esse é o nosso for tradicional. Primeiro, inicializa a variável uma única vez, depois verifica a condição, depois executa o nosso loop, e depois executa o incremento. Repara que o incremento vem aqui no caso do for.

O for tem as três partes de laço separadas por ponto e vírgula, e o código do laço dentro das chaves. O código do laço continua dentro das chaves e os pedaços do meu laço divididos em ponto e vírgula. O primeiro pedaço declara e inicializa uma variável, nesse meu exemplo; o segundo pedaço é uma condição booleana; e o terceiro pedaço é o que chamamos de incremento, mas é algo que é executado depois do laço, antes de verificar a condição.

Vamos executar esse código. Vou tirar o meu while. 1 até 9. Por que ele começou com 1? Porque começamos com int i = 1. Por que ele imprimiu o 9, mas não imprimiu o 10? Porque quando i valia 9, ele imprimiu o 9. Aí ele somou o 1, virou o 10. Aí ele verificou a condição, a condição é falsa. E aí ele saiu do laço, então ele não imprimiu o 10.

Cuidado com o caso em que o desenvolvedor escreveu um =, se na prova aparecer um <=, então ele vai executar esse meu comando também para o caso do igual. Vamos testar. Eu vou lá, compilo e executo. 10 está impresso.

E cuidado com a pegadinha mor. Eu posso fazer aqui um laço em que ao invés do sinal de menor ou igual, enquanto ele for maior do que 10, isso é, ele primeiro cria a variável, executa a condição, falso, ele nunca vai executar o meu laço. Vamos testar. Compilo e executo. Nada.

Então, depois de criar e inicializar variável, o próximo passo é a condição. Assim como o while, ele executaria a condição primeiro, antes do laço, aqui também, primeiro a condição. Cuidado com esse caso.

Um outro caso importante é tomar cuidado com o looping infinito. Se eu tiver uma variável int j = 1;, e sem querer, ao invés de o cara da prova, de propósito, colocar um j para te pegar, o que acontece é que o j nunca muda, você só está mudando o i. Então o j sempre é 1. Então o j sempre é menor ou igual a 10. O que acontece? Looping infinito.

O for também pode cair em looping infinito, tem que tomar cuidado com esse caso. Voltei aqui para o i, que é o caso que eu estou interessado. Outro ponto importante do meu for é que todas essas três partes são opcionais. Vamos ver o que acontece se eu tirar essa terceira parte, a parte do i++. Eu tiro ela e eu compilo e rodo o meu código. Imprimiu i = 1 eternamente. Como a variável não cresce mais, ficou i = 1, e ele imprimiu eternamente. Então a terceira parte sim, ela é opcional.

E a segundo parte, ela é opcional? Sim, ela é opcional. Se eu não colocar nada aqui dentro ela sempre vale true, então é como se fosse um laço que criou uma variável, e executasse sempre. Vamos testar. Compilo e rodo. Sempre, laço infinito.

O que mais? Se eu colocar um código aqui embaixo, por exemplo, int j = 2;, será que esse código vai ser executado? Nunca, porque esse laço aqui é eterno. Vamos testar e compilar. Ele não compila, por quê? Porque assim como o while, se o for é eterno, e o compilador é capaz de detectar isso com as maneiras tradicionais de detecção, isso é uma variável final que é sempre true, ou você passar um true, ou você não falar nada, ele percebe que esse código nunca será executado. Então se tem código depois desse for de laço infinito, que ele é capaz de perceber, só se ele for capaz de perceber, aí ele fala: "Não pode compilar porque esse código nunca será acessado".

"E a primeira parte, Guilherme, você falou que essa parte era opcional, vamos tirar fora?"; "vamos". Tirei e tento compilar. A variável i não existe, verdade, não adianta tentar usar uma variável que não existe. Vou imprimir mensagem. Vou tentar compilar, e ele compila. A declaração da variável é opcional, e eu rodo, e ele fica em um looping infinito, equivalente a um while true. Pode ser desinteressante, mas é importante então saber que os três pedaços são opcionais.

Mas existem outros casos importante que temos que perceber aqui. O meu for, quando eu declaro uma variável, For(int i = 0; i < 10; i++) {. Comecei do zero, vou imprimir o meu i.

Quando eu declaro as variáveis, eu não preciso declarar somente uma variável e inicializar ela, eu posso declarar duas variáveis. j começa com 10. E eu vou imprimir aqui tanto o i, quanto o j. Então ele vai imprimir "0 e 10, 1 e 10, 2 e 10, 3 e 10, 4 e 10".

Quando eu declaro uma variável aqui, e inicializo ela, eu posso declarar uma segunda variável usando a vírgula. Vamos tentar. Compilo e rodo. Posso declarar e inicializar quantas variáveis eu quiser aí dentro. Só que todas elas têm o mesmo tipo. Não posso declarar uma segunda variável long aqui. Vamos tentar. Compilei, quebrou.

E se eu colocar uma palavra int aqui? Todas têm o mesmo tipo, só que eu redefini, falei de novo que é int. Não pode. Aqui, depois que você falou o tipo da variável, vem uma série de variáveis, uma ou mais, que todas elas terão o mesmo tipo. Então int i = 0, j = 10, k = 5, porém, não posso definir agora outros tipos, ou ficar tentando redefinir como mesmo tipo.

O que mais? Esse último lado aqui da direita também pode ter mais de uma expressão. Ao mesmo tempo que eu somo 1 no i, eu quero diminuir 1 no j. Somou 1 no i, diminui 1 no j. Vamos testar. Compilo e rodo. 0 e 10, 1 e 9, 2 e 8, 3 e 7, 4 e 6, 5 e 5, 6 e 4, 7 e 3, 8 e 2, 9 e 1. Uma última variação que eu tenho aqui do meu for é, se eu já tenho as variáveis declaradas, eu já tenho a variável i, e já tenho a variável zero, então eu posso simplesmente inicializá-las, não preciso declarar e inicializar na primeira parte do for, eu posso somente inicializar quantas variáveis eu quiser.

Inicializei duas variáveis. Vamos testar. Compilo e rodo. Maravilha. Agora, e se uma variável fosse um int e a outra variável fosse um long, posso inicializar duas variáveis? Inicializar não tem problema, inicializar não tem nada a ver com declarar. Vamos lá. Compilo e rodo. Maravilha.

O que eu não posso fazer é misturar, uma inicializa e a outra declara; uma declara e a outra inicializa. Então eu não posso colocar aqui int i e j = 10, não pode misturar, ou inicializa e declara tudo, ou declara e inicializa tudo, ou só inicializa tudo. Não pode. E a outra variação faz menos sentido ainda. Não pode. Deixa as duas inicializadas lá fora.

E por fim, aqui no final, quando eu falei que estamos incremento e decrementando o i e o j, eu poderia fazer qualquer outra expressão, e executar qualquer expressão, não há restrição, desde que eu execute alguma coisa, chame alguma coisa, invoque alguma coisa. Só falar "j"; "j, o que, cara?". j é a mesma coisa que escrever um j aqui no meio do nada, não faz sentido nenhum.

Agora, se eu falar: "Olha, j", ao invés de j eu falar: "Imprima oi", println("oi"). Não tem problema, é uma expressão válida, estou executando alguma coisa. Então eu estou executando um System.out.println("oi")) {. Feio, mas compila e roda.

Aquele meu System.out que eu tinha colocado aqui, eu podia de uma maneira absurdamente bizarra, colocar ele aqui, antes de incrementar e decrementar. Coloco meu System.out, depois soma 1, depois diminuí 1, e coloca um laço vazio aqui dentro. Muito feio, mas compila, eu posso chamar algum método lá dentro, não tem problema nenhum, ele vai imprimir os valores para mim.

O que mais? Da mesma maneira que eu falei: "Olha, eu posso usar chaves", eu posso colocar aqui, ao invés de chaves, System.out.println("mensagem"), se o que eu vou executar aqui dentro do meu for é um único statement, uma única expressão, essa expressão não precisa necessariamente estar dentro de chaves, ela pode estar fora das chaves. Uma única expressão, os mesmos cuidados que tomamos sem expressão, sem uma única expressão, sem chaves, com while.

Vamos lá. Rodo aqui e ele executa bonitinho. Se eu tenho lá tudo que eu queria fazer naquela terceira condição, que é mega feio, mas possível, eu podia colocar só um ponto e vírgula. Não faça nada, isso aqui é para não fazer nada. É a mesma coisa que eu ter um ponto e vírgula voando. Pontos e vírgulas podem voar à vontade, não tem problema nenhum. Aqui eu tenho um ponto e vírgula voando, não faça nada, porque já estou fazendo tudo aqui dentro. Vamos testar. Eu coloco, compilo e rodo. Rodou bonitinho.

Agora, eu poderia não ter nada aqui também. É claro, se eu não tenho nada na minha expressão entre loops, e não tenho nada aqui fora, ele não vai imprimir nada. E como isso daqui sempre é menor do que 10, vai ficar em um looping infinito. Ele vai ficar em um looping infinito quietinho. Compilo e rodo.

Um outro tipo de loop importante é o loop que chamamos de Enhanced loop, que é quando eu tenho, por exemplo, uma array, alguma coisa que eu consigo iterar, por exemplo, uma array de números literais de 1 até 6. E eu vou falar For(int i = 0; i < numeros.length; i++) {.

O laço tradicional para passar por uns elementos. System.out.println(numeros[i]));. Só que ao invés de falar esses números de i, muito chato ficar falando números de i toda vez, então vou chamar de número dessa variável, uma variável temporária. Esse laço passa por todos os números e imprime eles. Vamos ver. Vou comentar esse código, compilo e rodo, 1 até 6, maravilha.

Como é muito comum pegarmos uma coleção, ou uma array de itens como 1, 2, 3, 4, 5, 6, e passar por todos eles de 1 até o último, d primeiro até o último, do elemento que está na posição zero até o último, criando uma variáveis temporária para iterar por esses elementos, e executar um loop, foi criado um for, que chamamos de enhanced for.

Esse for funciona da seguinte maneira, eu vou querer passar criando uma variável int número, então eu vou criar uma variável int número dentro de todos os números, dentro de todos os números. Imprima número. Isso é, ele está fazendo um for de 0 até 5, todos elementos, inclusive, imprimindo essa variável que ele declarou temporária.

Ele faz exatamente a tradução para esse código de cima. Vamos testar, enhanced for, javac, ele imprime a mesma coisa. Então, o enhanced for recebe a declaração de uma variável int.numero, essa variável, o tipo dela, tem que ser compatível com o tipo que está lá dentro dessa array, dessa coleção, ou de uma coleção, que não cai. Então, nesse caso eu tenho uma array de ints, então eu estou criando um int para cada elemento dentro daquela array. E aí eu imprimo cada um desses elementos. Assim como o for, ponto e vírgula é opcional. Assim como o for, chaves é opcional.

Eu comentei que o Foreach, o enhanced for, funciona tanto para arrays, quanto para coleções. As coleções também são iteráveis através de um Foreach. Na certificação que estamos vendo, somente é cobrado da gente a ArrayList. Vou criar uma ArrayList<String> nomes = new ArrayList<string>();. E dentro dessa ArrayList eu vou colocar nomes.add("guilherme"); e nomes.add("mario");. Coloquei dois nomes aí dentro.

Agora eu vou fazer o mesmo for que eu quero passar por todos os elementos. Como é que fazemos um for para passar por todos os elementos aqui? Diversas maneiras. Vamos ver elas dentro, quando trabalharmos com arraylist, e eu quero saber o enhanced for, como é que funciona o enhanced for para uma lista. O enhanced for com uma ArrayList funciona com For(string nome : Nomes) {. Declara cada uma das variáveis lá dentro como sendo nome, e aí imprime cada uma delas.

O que ele vai usar por baixo do pano é um iterator. Esse iterator, e as maneiras de iterar, além do enhanced for, por uma ArrayList, a gente vai ver quando a gente falar de uma ArrayList. O importante é saber o enhanced for que funciona também para a minha ArrayList. Vamos testar. Compilo. Faltou importar a ArrayList. importa java.util.arrayList;. Compilo e rodo. Guilherme e Mario. Maravilha, enhanced for.

O foreach tem algumas restrições. A primeira delas é que temos que passar por todos os elementos, do primeiro até o último. Se eu quiser pular elementos de dois em dois, não dá. Se eu quiser ir de trás para frente, não dá. Você tem que me dar uma coleção, me dar uma ArrayList, me dar uma array, etc, já invertida, aí eu vou estar passando "do último para o primeiro". Mas na verdade eu estou sempre passando do primeiro para o último, foi você que inverteu.

Ele sempre vai passar do primeiro até o último, um a um, quer você queira, quer você não queira.

O que mais que eu não consigo fazer? Consigo remover algum elemento que tem aí dentro? Deixa eu tentar. nome = null;. Não, eu só estou pegando a referência da variável nome e mandando apontar para null. Vamos tentar. nome = null;. Depois de imprimir, é claro, senão eu vou imprimir sempre null. Tento aqui, compilo, rodo, Guilherme e Mario. Imprimiu os dois, mas o que sobrou na minha ArrayList? System.out.println(nomes);. Vamos testar. Javac. Repara, sobrou os dois lá dentro. Mudar a referência de uma variável local não serve para nada.

Agora, e se invés disso eu tentar chamar o método remove. nomes.remove(nome);. Quer dizer, no final ela deveria ficar totalmente limpa. Vamos testar. Javac e java. Ele rodou para o Guilherme e apagou o Guilherme de lá de dentro, não imprimiu o Mário, e no final ficou ArrayList só com o Mário. Mega bizarro.

Quer dizer, ficar removendo coisas dentro do meu Foreach é perigoso, eu não sei direito o que vai acontecer aqui dentro. Eu tenho que tomar alguns cuidados. Quando eu faço o foreach eu vou, na prática, passar do primeiro até o último, e eu não vou pular elementos, porque eu não consigo pular elementos, e eu vou evitar remover coisas de lá de dentro, porque eu não sei direito o que vai acontecer. Então, na prática, não faremos isso.

Por fim, eu não tenho como saber se eu estou no primeiro nome, segundo nome, terceiro nome. Se eu quiser saber que eu estou no primeiro, segundos ou terceiro, eu vou ter que criar uma variável i e ficar somando um a um, mas aí é for tradicional, então faz o for tradicional.

Uma outra limitação é, eu não tenho um contador que está rolando a medida que eu estou dentro desse meu laço. Se eu quero um contador, na prática, eu vou criar um for tradicional.

Crie e uso laços do tipo do/while - Laços do tipo do/while

Nesta seção veremos um outro tipo de loop, um outro tipo de laço, com o while. Vamos aprender a criar e utilizar o laço do tipo do/while.

Primeira coisa, vou criar um arquivo TestaDowhile.java. Dentro desse arquivo vou criar minha classe. class TestaDowhile { public static void main(String[] args) {.

E qual a diferença entre ele e um while tradicional? Vou criar um while que começa com a variável int i = 1;, e vou falar while(i < 10) { System.out.println(i);, i++. E imprime. E vou fazer a mesma coisa com o j. int j = 1; do { System.out.println(j); j++: }while(j <10);.

Vamos testar. Compilo, rodo. 1 até 9, como era de se esperar, por quê? No primeiro, começamos com int i = 1;, e aí while(i < 10) {, sim, imprime i. Muda para 2, verifica. 2 é menor do que 10? Sim. Imprime 2. E assim vai até o 9. 9 é menor do que 10? Sim, imprime 9. Soma 1, 10. 10 é menor do que 10? Não. Se 10 não é menor que 10, para. Então, quer dizer, ele não imprimiu o número 10 no laço de cima.

E o laço de baixo? O laço de baixo começou com int j =1;. Imprimiu, somou, virou 2. Verifica, 2 é menor do que 10? Sim. Aí ele continua. Imprime 2, soma, vira 3. 3 é menor do que 10? Sim. Imprime 3. 4 é menor do que 10? Sim. Até 9. 9 é menor do que 10? Sim, imprime 9. 10 é menor do que 10? Não, não imprime 10.

O resultado foi o mesmo, então qual é a diferença entre o while, condição, bloco, e o do, bloco, while, condição, ponto e vírgula? Preciso lembrar a primeira coisa do ponto e vírgula. Se eu tirar o ponto e vírgula e tentar compilar o meu código, faltou um ponto e vírgula. Depois de do/while precisa do ponto e vírgula, senão, não compila. Primeira regra.

Qual é uma grande diferença aqui então? Repara que a condição está ou no começou, ou no final do bloco. Isso significa que no caso do while a condição vai ser verificada antes do bloco ser executado. E no caso do do/while a condição só vai ser executada após o bloco ser executado.

Logo de cara a condição é executada nesse caso. E nesse caso aqui, não, o bloco é executado pelo menos uma vez. Vamos fazer um teste. Vou mudar a variável i para 20, e a variável j para 20. Isto é, i já é maior do que 10 logo de cara, então nesse caso de cima ele nem deveria entrar no bloco, por quê? Porque i é menor do que 10? Não. Cai fora e não imprime nada.

E no caso de baixo? No caso de baixo j igual a 20. Entra no bloco, executa o bloco uma vez, aí verifica a condição. Vamos testar. Compilo, rodo. Somente o número 20.

Então, a grande sacada do do/while é que ele vai executar pelo menos uma vez o teu bloco, e depois vai verificar a condição. O while normal não, primeiro ele verifica a condição e aí ele executa o bloco, então, talvez, não seja executado nenhuma vez. Então essa é a grande diferença entre o while, que talvez não execute nenhuma vez porque a condição vem antes, e o do/while, que executa com certeza uma vez porque a condição vem depois.

Da mesma maneira que o while, se o meu código tem só uma linha, por exemplo, vou fazer um i++ aqui, e vou fazer um j++ aqui. Então meu código tem só uma linha. Nesses casos eu posso tirar as chaves, não posso? Então eu posso fazer aqui o while normal, e eu posso fazer um do/while de uma única linha. Funciona também. Vamos testar. Compilo e rodo. 1 a 9, 1 a 9, maravilha.

O que acontece se eu colocar duas linhas? Por exemplo, aqui eu pensar que quero imprimir também uma mensagem System.out.println("oi");. Você lembra aquela sacanagem que a prova pode fazer com a gente? Colocar a linha aqui alinhada justo para enganar a gente, parecer que vai imprimir dez vezes a palavra oi e imprime só uma?

Vamos testar. Aqui já sabemos, olha o "oi" lá uma única vez, porque ele executa só uma instrução no caso de estar sem chaves. E no caso do Do sem chaves? O que acontece se eu colocar mais uma linha aqui dentro? Eu tenho duas, está bem delimitado entre o Do e o while, porém, não compila.

Se você colocar mais de uma expressão aí dentro, não compila. Só pode ter uma expressão entre o Do e o while se você não colocar as chaves, senão nem compila. Diferente do anterior, por quê? Porque o próximo é a parte do seu loop, e depois do próximo é código normal, código normal que vem depois do seu laço. Aqui não, aqui você vai colocando duas coisas dentro do loop, mas você não colocou chaves, esqueceu das chaves. Não compila se tiver duas linhas aqui. Esse é um outro ponto importante.

Então do/while executa a condição depois, ele garante que executa o seu código uma única vez, o seu bloco uma única vez, e pode ter mais de uma instrução lá dentro, mas se tiver uma única instrução é opcional as chaves; se tiver sem chaves, com mais de uma instrução, não compila. Se em algum instante você esqueceu o ponto e vírgula depois da palavra while condição, também não compila.

Sobre o curso Certificação Java SE 7 Programmer I: Laços

O curso Certificação Java SE 7 Programmer I: Laços possui 60 minutos de vídeos, em um total de 31 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:

• Crie e use laços do tipo while
• Crie e use laços do tipo for, incluindo o enhanced for
• Crie e uso laços do tipo do/while
• Compare os tipos de laços
• Use break e continue