repetições e vetores
TRANSCRIPT
Estrutura de repetição (loop)
Em aulas anteriores vimos a rotina for. Esta executa a repetição de um comando ou bloco de
comandos através de uma variável de controle pré-determinada. O número de vezes que será
utilizada a estrutura é controlada por esta variável e a rotina tem a seguinte sintaxe:
for (variável de controle ; condição_boolean ; incremento)
{
<Comandos>;
<ou blocos de comandos. >;
}
Por exemplo:
for (i=0 ; i<5 ; i++)
{
JOptionPane.showMessageDialog (null ,"valor de i =" + i ) ;
}
Nesse exemplo a primeira vez que mostrar a janela de mensagem o valor de i será
0...porém, este comando de janela será repetido até o valor de i ser igual ou maior que 5(cinco) , a
condição mostrar-se false(falsa) e o programa parar a repetição. Sendo assim, na segunda vez em
que se repetir o comando teremos a exibição de uma segunda janela mostrando o valor de i que
passa a ser 1, depois outra janela passando o valor 2 e assim sucessivamente.
Rotina While
Temos outras formas de criar uma rotina de repetição. Uma delas é usarmos a rotina while
que utiliza uma variável de controle inicial juntamente com uma condição que determina se a rotina
será executada ou não, se continua a repetição ou não. Assim, o laço while não executa se a
condição criada for falsa logo no início, porém enquanto ela for verdadeira são repetidos os
procedimentos que fazem parte do seu escopo. Veja a sintaxe:
while (<condição>)
{
<bloco-de-comandos>
}
Exemplo:
while (i<=10)
{
soma=soma+Integer.parseInt(JOptionPane.showInputDialog(i+"º número..."));
i=i+1;
}
Nesse exemplo temos uma comparação (condição) inicial na qual a rotina só será executada caso
a variável i seja menor ou igual a dez. É feita uma soma na qual deverá ser informado o valor pelo
usuário e logo após a variável de controle i é incrementada.
O exemplo a seguir sorteia um número de 0 a 100 e então vai pedindo palpites, caso o usuário
consiga acertar paramos o programa, se não continuamos pedindo palpites. Cada iteração do laço
é contada como tentativa, além disso, devemos informar ao usuário se o palpite é maior ou menor
que o número sorteado. Veja o código:
import javax.swing.*;
import java.util.Random;
class Acerteonumero
{
public static void main(String args[ ])
{
// declarar variáveis
int sorte=0,i=0;
double num;
// sortear número
num = (int)(Math.random()*100);
JOptionPane.showMessageDialog(null,"Advinhe o número da sorte! ");
// rotina de repetição para acerto
while (num!=sorte)
{
sorte=Integer.parseInt(JOptionPane.showInputDialog("Adivinhe o número da
sorte!!!\n entre [0...100]"));
i++;
if (((int)num)==sorte)
{
JOptionPane.showMessageDialog(null,"Acertou em "+i+" tentativa(s)!");
break;
}
if (((int)num)<sorte)
{
JOptionPane.showMessageDialog(null,"menor");
}
if (((int)num)>sorte)
{
JOptionPane.showMessageDialog(null,"maior");
}
}//fim while
}//fim método
}// fim classe
Podemos também usar a rotina while para restringir a saída de um programa exemplo:
// importar a biblioteca de métodos.
import javax.swing.*;
class raiz
{
public static void main(String args[])
{
// declaração de variáveis
int num,i=0;
while(i==0)
{
num=Integer.parseInt(JOptionPane.showInputDialog("Digite um número para o calculo..."));
// comparação se o número é negativo
if (num<=0)
{
JOptionPane.showMessageDialog (null,"Não há Raiz quadrada!","Erro",
JOptionPane.ERROR_MESSAGE);
}
else
{
JOptionPane.showMessageDialog (null,"Raiz quadrada é...\n"+ Math.sqrt(num));
}
i=JOptionPane.showConfirmDialog(null,"Deseja Continuar ?","Pergunta",
JOptionPane.YES_NO_OPTION);
}//fim while
}//fim método main
}//fim classe
Estrutura de repetição (loop)
while
Exercícios usando comando while.
Neste primeiro exercício usaremos a rotina de repetição para uma tomada de decisão no
programa, enquanto o usuário decidir calcular, o programa não encerra.
// importar a biblioteca de métodos.
import javax.swing.*;
class area_retangulo
{
public static void main(String args[])
{
// declaração de variáveis
int base , altura,sair=0;
while(sair==0)
{
//mensagem ao usuário
base=Integer.parseInt(JOptionPane.showInputDialog("Digite a base do
retângulo..."));
altura=Integer.parseInt(JOptionPane.showInputDialog("Digite a altura do
retângulo..."));
//saída de valores e mensagens
JOptionPane.showMessageDialog (null,"Área do retângulo é ..."+ base*altura);
sair=JOptionPane.showConfirmDialog
(null,"Deseja calcular outro retângulo ?","Pergunta", JOptionPane.YES_NO_OPTION);
}
}//fim método main
}//fim classe
Neste segundo programa vemos que através da rotina de repetição temos como permitir a entrada
de dados controlada pelo usuário.
import javax.swing.*;
class media
{
public static void main(String args[])
{
// declaração de variáveis
double notas=0;
int i=0,sair=0;
JOptionPane.showMessageDialog (null,"vamos calcular a média do aluno");
while(sair==0)
{
i++;
notas=notas+Double.parseDouble(JOptionPane.showInputDialog("Digite a nota "+i));
sair=JOptionPane.showConfirmDialog
(null,"Deseja Continuar ?","Pergunta", JOptionPane.YES_NO_OPTION);
}
// calculando a média
JOptionPane.showMessageDialog (null,"O aluno teve média..."+ notas/i);
}//fim método main
}//fim classe
Também podemos usar a rotina de repetição para forçar o usuário a digitar um valor válido a seu
programa...
import javax.swing.*;
class dividir
{
public static void main(String args[])
{
// declaração de variáveis
int sair=0,dividendo,divisor;
while (sair==0)
{
dividendo=Integer.parseInt(JOptionPane.showInputDialog("Digite o dividendo..."));
divisor=Integer.parseInt(JOptionPane.showInputDialog("Digite o divisor..."));
while(divisor==0)
{
divisor=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite o divisor
diferente de 0(zero)...","Erro...não divide por zero!!!", JOptionPane.ERROR_MESSAGE));
}
JOptionPane.showMessageDialog (null,"Resultado..."+dividendo/divisor );
sair=JOptionPane.showConfirmDialog(null,"Deseja Continuar ?","Pergunta",
JOptionPane.YES_NO_OPTION);
}
}//fim método main
}//fim classe
Vetores ( arrays)
Arrays
A definição de arrays é a seguinte:
- São objetos que armazenam diversas variáveis do mesmo tipo. De forma simples um Array é um
conjunto de elementos de um mesmo tipo de dado onde cada elemento desse conjunto é
acessado através de um índice. Um array é também conhecido como vetor (quando
unidimensional) ou matriz (quando bidimensional).
Citando um exemplo; ter que utilizar uma coleção de nomes, digamos 50 nomes através de
variáveis simples, tais como nome1, nome2, nome3.... nome50, com certeza esta não é a melhor
forma de declararmos estas variáveis, perderíamos muito tempo na digitação, nosso programa
poderia ficar confuso e também perder performance.
Na maioria das linguagens temos o objeto tipo vetor em Java não é diferente temos o tipo array,
que pode ser visto como uma coleção de variáveis do mesmo tipo, sendo que cada elemento é
acessado através de um índice (uma posição).
Em Java é possível utilizar arrays multidimensionais, o array com uma dimensão é normalmente
chamado de vetor. Um vetor que já estamos acostumados a encontrar é o args, parâmetro
recebido através do método main, este é um vetor de Strings.
A sintaxe básica para declarar um array é:
<tipo-do-dado> <nome-do-array[ ]> = new <tipo-do-dado>[quantidade]
Exemplos:
int numeros[ ] = new int[10];
String nomes[ ] = new String[50];
A seguir a estrutura de um vetor:
1ª posição.
Tamanho do vetor é 10
elemento (posição 6)
0 1 2 3 4 98765
Índices (posições)
Y
Na estrutura de um vetor temos o tamanho que é determinado quando o declaramos no caso do
exemplo acima int numeros = new int [10]... 10(dez) é o número de elementos que podemos
armazenar no vetor. Elemento é o dado armazenado no vetor que é localizado através do índice,
que é sua posição ou endereço do elemento no vetor.
Geralmente para preenchermos um vetor de elementos (dados) usamos rotinas de repetição
usando um contador como referencia ao índice do vetor exemplo:
Programa 1:
import javax.swing.*;
class nomes
{
public static void main(String args[ ])
{
// declarar variáveis
String amigos[ ] = new String[10];
int i;
String lista="";
//lêr nomes do usuário, preencher vetor.
for (i=0;i<10;i++)
{
amigos[i]=JOptionPane.showInputDialog(null, i + 1 + "º Amigo(a) ");
lista=lista + amigos[ i ] + "\n";
}
JOptionPane.showMessageDialog(null,"Lista de amigos :\n"+lista);
}//fim método
}// fim classe
No próximo programa iremos preencher o vetor e localizar o elemento deste pelo número de seu
índice, que será fornecido pelo usuário. Para preencher o vetor usaremos rotina de repetição for.
Programa 2:
import javax.swing.*;
class elementos
{
public static void main(String args[])
{
// declarar variáveis
String amigos[] = new String[10];
int i,elemento;
//lêr nomes do usuário, preencher vetor.
for (i=0;i<10;i++)
{
amigos[i]=JOptionPane.showInputDialog(null,i+1+"º Amigo ");
}
/fornecer o número do indice
elemento=Integer.parseInt(JOptionPane.showInputDialog(null,"Digite o número do indice...
[0 ... 9]"));
JOptionPane.showMessageDialog(null,"Amigo : "+amigos[elemento]);
}//fim método.
}// fim classe.
EXERCÍCIO
Crie um programa com vetores que leia 10(dez) números distintos, armazene os no vetor e
mostre a somatória destes números.
Vetores Múltiplos e Matriz ( arrays)
Arrays
A definição de arrays é a seguinte:
- São objetos que armazenam diversas variáveis do mesmo tipo. De forma simples um Array é um
conjunto de elementos de um mesmo tipo de dado onde cada elemento desse conjunto é
acessado através de um índice. Um array é também conhecido como vetor (quando
unidimensional) ou matriz (quando bidimensional).
Usando mesmo exemplo da aula anterior; ter que utilizar uma coleção de nomes e notas de
alunos, 50 nomes através de variáveis simples, tais como nome1, nome2, nome3.... nome50 e
respectivas 50 notas nota1, nota2, nota3... nota50. Pois bem temos uma tabela com nomes e
notas, informações de tipo de dados diferentes então para solucionar isto criam - se dois vetores
que ficaram ligados através de seus índices.
Nome Dav
i0 1 2 3 4 5 6 7 8 ... 49
Notas 9.80 1 2 3 4 5 6 7 8 ... 49
No exemplo acima um aluno Davi e sua nota 9.8... para trabalhar os dados deste aluno usa se o
índice como referencia tendo a mesma posição para o nome do aluno e sua nota. (nome [ 4 ] ;
notas[ 4 ] ).
Em Java é possível utilizar arrays multidimensionais (matriz). Caso tenha uma seqüência numérica
ou de dados do mesmo tipo em linhas e colunas.
A sintaxe básica para declarar uma matriz é:
<tipo-do-dado> <nome-da-matriz[ ] [ ] > = new <tipo-do-dado>[ nº. de linhas] [nº. de colunas]
Exemplos:
int matriz[ ] [ ] = new int [3][4];
A seguir a estrutura da matriz:
Na estrutura de uma matriz temos o tamanho que é determinado pelo número de linhas e colunas
quando declarada, exemplo acima int matriz [ ] [ ] = new int [3][4] . O primeiro colchetes [3]
determinam o número de linhas e o segundo colchetes determina o número de colunas, então a
matriz pode armazenar 12 elementos.
Elemento é o dado armazenado na matriz que é localizado através do índice da linha e da coluna,
que é sua posição ou endereço na matriz.
1
10
0
2 3
2
índices (posições)
linhas e colunas
Tamanho do matriz é [ 3 ] [ 4 ]
Xelemento
( posição [ 1 ] [ 2 ] )