Estruturas de Repetição em Java

1 – Linguagem de Programação
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);
}
}
http://erinaldosn.wordpress.com
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
Separador
ponto-e-vírgula
for (
Palavra
chave
int cont = 1;
Variável
de controle
Separador
ponto-e-vírgula
cont <= 10;
Condição de
continuação do loop
cont++ )
Incremento da
variável de controle
Valor inicial
da variável
de controle
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.
http://erinaldosn.wordpress.com
3 – Linguagem de Programação
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[]){
//declaração de variáveis
float soma, num, media;
int cont;
Scanner leia = new Scanner(System.in);
//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[]){
//declaração de variáveis
float soma, num, media;
int cont;
Scanner leia = new Scanner(System.in);
//inicialização de variáveis
soma = 0;
cont = 0;
//faça (repita)
do{
//armazene em num o valor digitado pelo usuário
http://erinaldosn.wordpress.com
Estrutura de Repetição – 4
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';
Scanner leia = new Scanner(System.in);
/*
* 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 Expressão de exemplo
Explicação
Atribuições
atribuição
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
http://erinaldosn.wordpress.com
5 – Linguagem de Programação
Operador de Expressão de exemplo
atribuição
*=
e *= 5
/=
f /= 3
%=
g %= 9
Explicação
Atribuições
e=e*5
f=f/3
g=g%9
20 para e
2 para f
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 Explicação
de exemplo
Incrementa a por 1 e então utiliza o novo
++
pré-incremento
++a
valor de a na expressão em que a reside.
Utiliza o valor atual de a na expressão
++
pós-incremento
a++
em que a reside, então incrementa a por
1.
Decrementa b por 1 e então utiliza o
-pré-decremento
--b
novo valor de b na expressão em que b
reside.
Utiliza o valor atual de b na expressão
-pós-decremento b-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
http://erinaldosn.wordpress.com
Estrutura de Repetição – 6
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 {
public static void main(String args[]){
int y, x = 1, total = 0;
while (x <= 10){
y = x * x;
System.out.println(y);
total += y;
++x;
http://erinaldosn.wordpress.com
7 – Linguagem de Programação
}
System.out.printf("O total é %d\n", total);
}
}
public class prog4_17 {
public static void main(String args[]){
int i = 1;
while (i <= 10){
System.out.println(i % 2 == 1 ? "*****" :
"+++++");
++i;
}
}
}
public class prog4_18 {
public static void main(String args[]){
int linha = 10, coluna;
while (linha >= 1){
coluna = 1;
while (coluna <= 10){
System.out.print(linha % 2 == 1 ? "<" :
">");
++coluna;
}
--linha;
System.out.println();
}
}
}
public class prog4_19 {
public static void main(String args[]){
for (int i = 1; i <= 10; i++){
for (int j = 1; j <= 5; j++)
System.out.print('0');
System.out.println();
}
}
}
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(„*‟);
System.out.println();
}
}
n = 1;
http://erinaldosn.wordpress.com
Estrutura de Repetição – 8
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{
public static void main(String args[]){
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
http://erinaldosn.wordpress.com
9 – Linguagem de Programação
Michael Goodrich, Roberto Tamassia
Porto Alegre: Bookman, 2007
Use a cabeça Java
Kathy Sierra e Bert Bates
Rio de Janeiro: Alta Books, 2005
http://erinaldosn.wordpress.com