Estruturas de Repetição em Java - Tecnologia da Informação · PDF filepublic static void main(String args[]){ //declaração de variáveis float soma, num, media; int cont; Scanner

1 – Linguagem de Programação

http://erinaldosn.wordpress.com

Estruturas de Repetição em Java

A realização da repetição controlada por contador requer:

1. Uma variável de controle (ou contador de loop).

2. O valor inicial da variável de controle.

3. O incremento (ou decremento) pelo qual a variável de controle é modificada a cada

passagem pelo loop (iteração do loop).

4. A condição de continuação do loop que determina se o loop deve continuar.

Instrução de repetição FOR O Java fornece a instrução de repetição for, que especifica os detalhes da

repetição controlada por contador em uma única linha de código.

Exemplo 1: ler 8 números fornecidos pelo usuário, calcular e exibir a média entre eles. /*

* o programa utiliza a classe Scanner

* para ler os números digitados via teclado

* pelo usuário

*/ import java.util.Scanner;

//classe (o nome do programa ex1_for.java) public class ex1_for {

//método principal onde inicia a execução do programa public static void main(String args[]){

//declaração de variáveis float soma, num, media;

int cont;

Scanner leia = new Scanner(System.in);

//incializa a variável soma = 0;

/*

* para cont começando com 1;

* até cont menor ou igual a 8;

* increment cont de 1 em 1

*/ for (cont = 1; cont <= 8; cont++){

/*

* a variável leia armazena o valor digitado pelo usuário

* esse valor é atribuído à num

*/ num = leia.nextFloat();

//soma armazena o valor de soma + o valor de num soma+=num; //soma = soma + num

} //fim do loop

/*

* calcula a média

* o valor de soma dividido pelo número de iterações

*/ media = soma / cont;

//exibe a média dos números digitados System.out.println("Média ="+media);

}

}

Estrutura de Repetição – 2


Em Java a expressão cont ← cont + 1 é representada por cont++.

As variáveis quando declaradas não possuem valores, seu conteúdo é nulo e

operações aritméticas que envolvem nulos sempre resultam em nulos. Às vezes também

será necessário acumular valores, isto é, calcular o somatório de um conjunto de

valores. Para isso, também será necessário utilizar uma variável de apoio, que pode ser

do tipo inteiro ou real, de acordo com os valores que serão acumulados acumulador = 0;

acumulador = acumulador + valor;

Componentes de cabeçalho

for ( int cont = 1; cont <= 10; cont++ )

Em geral as instruções for são utilizadas para repetição controlada por

contador. Se a expressão inicialização no cabeçalho for declara a variável de controle,

a variável de controle pode ser utilizada somente nessa instrução for – ela não existirá

fora da instrução for.

Essa utilização restrita do nome da variável de controle é conhecida como o

escopo da variável. O escopo de uma variável define onde ela pode ser utilizada em

um programa.

Todas as três expressões em um cabeçalho for são opcionais. Se a condição de

continuação do loop for omitida, o Java assume que a condição de continuação do loop

é sempre verdadeira, criando um loop infinito.

Você poderia omitir a expressão incremento se o programa calcular o

incremento com instruções no corpo do loop ou se nenhum incremento for necessário.

A expressão incremento em uma instrução for atua como se ela fosse uma instrução

independente no fim do corpo do for.

A instrução de repetição WHILE Uma instrução de repetição permite ao programador especificar que um

programa deve repetir uma ação enquanto alguma condição permanecer verdadeira.

Palavra

chave

Variável

de controle

Valor inicial

da variável

de controle

Condição de

continuação do loop

Incremento da

variável de controle

Separador

ponto-e-vírgula

Separador

ponto-e-vírgula



A(s) instrução(ões) contida(s) na instrução de repetição while constitui(em) o

corpo da instrução de repetição while, que pode ser uma única instrução ou um bloco.

Por fim, a condição se tornaria falsa. Nesse ponto a repetição termina e a primeira

instrução depois da instrução de repetição é executada.

Exemplo 2: ler 8 números fornecidos pelo usuário, calcular e exibir a média entre eles. import java.util.Scanner;

//classe public class ex2_while {

//método principal public static void main(String args[]){


int cont;


//inicialização de variáveis soma = 0;

cont = 0;

//enquanto a variável cont for menor que 8 while (cont < 8){ //inicia o loop

//armazena na variável num o valor digitado via teclado num = leia.nextFloat();

//a variável soma acula a soma com num soma+=num;

//incrementa o contador cont cont++;

}//fim do loop

//calcula a média dos números somados media = soma / cont;

//exibe (escreve) a média System.out.println("Média = "+media);

} // fim do método principal

} //fim da classe

A estrutura de repetição DO...WHILE A instrução do... while é semelhante à instrução while. Em while o programa

testa a condição de continuação do loop no começo do loop antes de executar o corpo

do loop. Se a condição for falsa, o corpo nunca executa. A instrução do... while testa a

condição de continuação do loop depos de executar o corpo do loop, portanto, o corpo

sempre executa pelo menos uma vez. Quando uma instrução do... while termina a

execução continua cm a próxima instrução na sequência.

Exercício 3: ler 8 números fornecidos pelo usuário, calcular e exibir a média entre eles. import java.util.Scanner;

public class ex3_do_while {

//método principal public static void main(String args[]){


int cont;


//inicialização de variáveis soma = 0;

cont = 0;

//faça (repita) do{

//armazene em num o valor digitado pelo usuário



num = leia.nextFloat();

//acumula a soma dos números digitados soma+=num;

//incrementa o contador cont++;

}while (cont < 8);//enquanto (até) cont ser menor que 8

//calcula a média dos números digitados media = soma / cont;

//exibe a média System.out.println("Média = "+media);

}//fim do método principal

}//fim da classe ex3_do_while

Exemplo 4: a cada iteração pergunta-se ao usuário se deseja continuar. Com base na

resposta, a condição estabelecida é testada. import java.util.Scanner;

public class ex4_while {

public static void main(String args[]){

//declaração e inicialização de variáveis float soma=0, num, media;

int cont = 0;

char resposta='S';


/*

* enquanto a variável respostar

* for igual a 'S' ou 's' faça

*/ while (resposta == 'S' || resposta == 's'){//início do loop

//armazena em num o valor digitado pelo usuário via teclado num = leia.nextFloat();

//acumula a soma dos números digitados soma+=num;

//acumula um contador de quantos números foram digitados cont++;

//exibe a mensagem se o usuário quer continuar System.out.println("Deseja continuar?");

//armazena em resposta o caractere digitado pelo usuário resposta = leia.next().charAt(0);

}//fim do loop

//calcula a média da soma dos números digitados media = soma / cont;

//exibe a média System.out.println("Média = "+media);

}//fim do método principal

}//fim da classe

Operadores de atribuição compostos O Java fornece vários operadores de atribuição compostos para abreviar

expressões de atribuição. A tabela abaixo mostra os operadores de atribuição compostos

aritméticos, expressões de exemplo que utilizam os operadores e explicações do que os

operadores fazem.

Operador de

atribuição

Expressão de exemplo Explicação Atribuições

Suponha: int c = 3, d = 5, e = 4, f = 6, g = 12;

+= c += 7 c = c + 7 10 para c

–= d –= 4 d = d – 4 1 para d



Operador de

atribuição

Expressão de exemplo Explicação Atribuições

*= e *= 5 e = e * 5 20 para e

/= f /= 3 f = f / 3 2 para f

%= g %= 9 g = g % 9 3 para g

Operadores de incremento e decremento O Java fornece dois operadores unários para adicionar 1 ou subtrair 1 do valor

de uma variável numérica. Um operador de incremento ou de decremento que é

colocado antes de uma variável é chamado operador de pré-incremento ou operador de

pré-decremento, respectivamente. Um operador de incremento u decremento que é

colocado depois de uma variável é chamado operador de pós-incremento ou operador de

pós-decremento, respectivamente.

Pré-incrementar (ou pré-decrementar) uma variável faz com que a variável seja

incrementada (decrementada) por 1 e então o novo valor da variável é utilizado na

expressão em que aparece. Pós-incrementar (pós-decrementar) a variável faz com que o

valor atual da variável seja utilizado na expressão em que ela aparece e então o valor da

variável é incrementado (decrementado) por 1.

Os operadores de incremento e decremento unários devem ser colocados ao lado

de seus operandos sem espaços no meio.

A tabela abaixo demonstra os operadores de incremento e de decremento.

Operador Chamado Expressão

de exemplo

Explicação

++ pré-incremento ++a Incrementa a por 1 e então utiliza o novo

valor de a na expressão em que a reside.

++ pós-incremento a++

Utiliza o valor atual de a na expressão

em que a reside, então incrementa a por

1.

-- pré-decremento --b

Decrementa b por 1 e então utiliza o

novo valor de b na expressão em que b

reside.

-- pós-decremento b--

Utiliza o valor atual de b na expressão

em que b reside, então decrementa b por

1.

Exercícios 1. Identifique e corrija os erros em cada um dos seguintes conjuntos de código:

a) while (c <= 5 ) {

produto *= c;

++c;

b) if (sexo == 1) System.out.println(“Mulher”);

else;

System.out.println(“Homem”);

c) if (idade >= 65); System.out.println(“idade maior oi igual a”);

else



System.out.println(“a idade é menor que 65)”;

d) int x = 1, total; while (x <= 10)

{

total += x;

++x;

}

e) while (x <= 100) total += x;

++x;

f) while (y > 0)

{

System.out.println(y);

++y;

g) i = 1; while (i <= 10);

i++;

}

h) for (k = 0.1; k != 1.0; k += 0.1) System.out.println(k);

i) switch(n){

case 1:

System.out.println(“O número é 1”);

case 2:

System.out.println(“O número é 2”);

break;

default:

System.out.println(“O número não é 1 nem 2”);

break;

}

j) for (i = 100, i >= 1, i++)

System.out.println(i);

k) switch (valor % 2){ case 0:

System.out.println(“Inteiro par”);

case 1:

System.out.println(“Inteiro ímpar”);

}

2. O que há de errado com a instrução while a seguir? while (z >= 0)

soma += z;

3. O que os seguintes programas imprimem? public class prog4_16 {


int y, x = 1, total = 0;

while (x <= 10){

y = x * x;

System.out.println(y);

total += y;

++x;



}

System.out.printf("O total é %d\n", total);

}

}

public class prog4_17 {


int i = 1;

while (i <= 10){

System.out.println(i % 2 == 1 ? "*****" :

"+++++");

++i;

}

}

}



int linha = 10, coluna;

while (linha >= 1){

coluna = 1;

while (coluna <= 10){

System.out.print(linha % 2 == 1 ? "<" :

">");

++coluna;

}

--linha;

System.out.println();

}

}

}



for (int i = 1; i <= 10; i++){

for (int j = 1; j <= 5; j++)

System.out.print('0');


}

}

}

4. O que os seguintes segmentos de programas fazem? for (i = 1; i <= 5; i++){

for (j = 1; j <= 3; j++){

for (k = 1; k <= 4; k++)

System.out.print(„*‟);


}

}

n = 1;



while (n <= 10)

System.out.println(n++);

for (int i = 19; i >= 1; i -= 2)

System.out.println(i);

cont = 2;

do{

System.out.println(cont);

cont += 2;

} while (cont <= 100)

5. Um programa Java está todo misturado. Reorganize os trechos de código para criar

o programa. Adicione as chaves necessárias.

if (x == 1) {

System.out.print(“d”);

x = x – 1;

}

if (x == 2) {

System.out.print(“b c”);

}

class embaralha{


if (x > 2) {

System.out.print(“a”);

}

int x = 3;

x = x – 1;

System.out.print(“-“);

while (x > 0){

Esse programa produz a saída listada abaixo:

Bibliografia Lógica de programação e estrutura de dados, com aplicações em Java

Sandra Puga, Gerson Rissetti

São Paulo: Pearson Prentice Hall, 2009

Java: como programar

H. M. Deitel, P. J. Deitel

São Paulo: Pearson Prentice Hall, 2005

Estrutura de dados e algoritmos em Java



Michael Goodrich, Roberto Tamassia

Porto Alegre: Bookman, 2007

Use a cabeça Java

Kathy Sierra e Bert Bates

Rio de Janeiro: Alta Books, 2005

Documents

Estruturas de Repetição em Java - Tecnologia da Informação · PDF filepublic static void main(String args[]){ //declaração de variáveis float soma, num, media; int cont; Scanner