Isto não é exequível!... B[8][6] A[10] Slides_Java_4

(1)

Sistemas Informáticos I, 2005-2006

Slides_Java_4

A[10]

B[8][6]

• Imaginemos que é necessário escrever um programa que:

–leia uma lista de 50 alunos e as respectivas notas.

–calcule a nota média.

–escreva a diferença da nota de cada aluno para a nota média.

• Seria necessário declarar variáveis separadas para cada um

dos 50 alunos:

String nome1, nome2, nome3, …, nome50 int nota1, nota2, nota3, …, nota50

Isto não é exequível!...

• Solução: utilizar

tabelas (arrays)

• Uma tabela é um objecto que contém uma lista

ordenada de elementos,

todos do mesmo tipo

.

• Os elementos são indexados por um índice que pode

variar entre

0 e

n-1

, sendo

n

a dimensão da tabela.

n

(2)

• Para criar uma tabela:

–Declarar a tabela

double [] notas; // declara uma tabela de floats

double notas[]; // o mesmo efeito...

–Instanciar a tabela (é necessário usar newpara criar a tabela porque as tabelas são objectos)

notas = newdouble [50]; // cria uma tabela com 50 doubles

–Inicializar e aceder aos elementos

notas [0] = 14.7; notas [1] = 10.2; ...

soma = notas [0] + notas [1]; System.out.println(notas [0]);

notas[49] = 20.0;

• Um elemento de uma tabela é um espaço onde se pode armazenar

um valor do tipo declarado.

• Os elementos de uma tabela podem ser usados em qualquer ponto

de um programa onde possa ser usado um elemento desse tipo.

–Ex: notas [1]pode ser usado nas mesmas circunstâncias em que

uma variável do tipo double pode ser usada (podemos atribuir-lhe um valor, imprimi-la, utilizá-la em expressões, …)

• Declarar um array:

int r[]; double nums[]; String nomes[];

• Criar um array

r = new int[10]; nums = new double[100]; int s[] = new int[20]; char c[] = new char[20];

• Indexar os elementos de um array:

r[0] = 20; r[9] = 100; nums[99] = 3.2; s[0] = 5; s[1] = r[0]; classNotas {

public staticvoidmain(String arg[]) { finalintMAX = 50;

float []notas = newfloat[MAX];

intconta = 0;

floatn, media;

// leitura das notas (termina com nº negativo)

do{

System.out.print ("Nota do aluno "+conta+" "); n = Keyboard.readFloat();

if(n >=0) {

notas [conta] = n;

conta ++; }

(3)

// cálculo da média floatsoma=0; for(inti=0; i<conta; i++)

soma = soma + notas[i]; if(conta > 0)

media = soma / conta;

elsemedia = 0;

System.out.println (media);

// Diferenças para a média

System.out.println ("Diferenças para a média:");

for(inti=0; i<conta; i++)

System.out.println ("Aluno "+i+" "+(notas[i]-media)); }

}

• É possível criar e inicializar uma tabela de forma

semelhante aos tipos simples:

int diasMes[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

–A tabela é criada com o espaço suficiente para os dados

fornecidos na inicialização (12 neste caso).

–Assim, a instrução anterior é equivalente a:

int diasMes[] = new int [12]; diasMes [0] = 31; diasMes [1] = 28; … diasMes [11] = 31;

!

int n[ ] = {10,34,48,35,5,7,3,8,6,12};

• Alternativamente:

int n[] = new int[10];

n[0] = 10;

n[1] = 34;

...

n[9] = 12;

"

!" ! # $ % & " ' ( ) ) * * + + * )* , ,

(4)

#

-! " - - - - - - - - - - , ( ) ) * * + + * )* , ,

$

%

&

• int tab[] = new int[100];

• Escreva umas linhas de código para:

(a) colocar os 100 primeiros inteiros (1,2,...,100)

na tabela tab[0],...,tab[99];

(b) colocar os 50 primeiros números pares

(2,4,...,100) na tabela tab[0],...,tab[49];

(a) colocar os 100 primeiros inteiros em ordem

inversa (100, 99,...,1) na tabela tab[0],...,tab[99];

'

int tab[] = new int[100];

for(int i=0; i < 100; i++)

tab[i] = i+1;

for(int i=0; i < 50; i++)

tab[i] = 2*(i+1);

for(int i=0; i < 100 ; i++)

tab[i] = 100-i;

for(int i=100; i > 0 ; i--)

tab[100-i] = i;

• Quando se cria uma tabela com n elementos, esse é o número máximo

que a tabela pode armazenar.

– Uma vez criada não é possível alterar o seu tamanho.

– O campo lengthguarda o número máximo de elementos que a

tabela pode armazenar. Este campo apenas pode ser lido:

. / )(

• Isto não implica que a tabela deva estar sempre cheia:

– Em cada momento poderá conter entre 0 e n elementos

– Um cuidado importante quando se usam tabelas é respeitar os limites para os índices (0 a n-1)

– A utilização de índices fora dos limites leva o Compilador de Java a

gerar uma excepção:

Java.lang.ArrayIndexOutOfBoundsException

(5)

( ( )0 1 / (2 3 4 ++ / , , java.lang.ArrayIndexOutOfBoundsException at ArrayBound.main(ArrayBound.java:7)

Exception in thread "main" Finished executing

)

* (

55 6 ( ( ( ( ( ( ) 7( (2 ! -$ -& - -" -' ' -# # -8 , # - -! - , ( ) ) * ( 3 * + )( ( ) ) * ( 3 ! * + ! )( ( ) ) * ( 3 * + )( , ,

&

55 55 1 55 9 + 1 : ( ( (2 1 -! - -# -$ -% -& -" -' - , 9 (2 55 ; : ( 3 4 ++ , , ,

for(int i=0; i < 10; i++){ C[i] = A[i] + B[i];

System.out.println("C["+i+"]= "+ C[i]);

• Uma tabela tanto pode conter elementos de um tipo simples, como referências para outros objectos, como Strings por exemplo.

–String [] frases = new String [25];

reserva espaço para 25 referências para objectos String.

– No entanto, esta instrução não cria as Strings propriamente ditas, mas apenas as referências respectivas.

– As Strings têm que ser criadas explicitamente:

frases [0] = new String (“Bom dia”); ou

frases [1] = “Bom dia”; ....

(6)

( ( )0 6 ( ) ) *< ( ( * = ( ) ( > ( ) ) * >< ?@ 6 A A B * 6 (2 55 ( C ( 3 4 ++ ( ) ) *< ( *+ +* D* 6 = ( ) ( 7 ( 55 ( , ( ) ) * < B . E * 3 4 ++ ( ) ) *< ( *+ +* D*+ 6 , ,

• Uma tabela

bi-dimensional

representa uma matriz, com

linhas e colunas.

• Cada elemento de uma tabela

bi-dimensional

é

referenciado usando dois índices: um para as linhas e

outro para as colunas.

• Na realidade, uma tabela

bi-dimensional

é uma tabela

de tabelas, ou seja é uma tabela uni-dimensional em

que cada elemento é uma referência para um objecto

tabela.

• Exemplo:

2 A

(2

$

• Por exemplo, imaginemos que precisamos de armazenar

as classificações de 200 alunos em 4 testes.

• Poderíamos usar:

float [][] notas = new float [200][4];

–Neste caso os índices podem variar entre 0 e 199 e entre 0 e 3,

sendo errado tentar aceder a índices fora destas gamas.

–Para aceder a um dado elemento usam-se 2 índices:

notas [0][0] = 14.3; notas [199][3] = 10.2;

–Para saber a dimensão da tabela:

int numLinhas = notas.length; int numColunas = notas [0].length;

(7)

+

4

3

2

1 -!,- -#, ,

• É possível criar e inicializar uma tabela

bi-dimensional numa única instrução:

(

- - ,- - - ,,

–

Esta instrução cria uma tabela de inteiros com duas

linhas e três colunas, inicializada com os valores dados

• Alternativa:

(2

3

4 ++

3 F

F 4

F++

F

+F

+

1 0 1 0 1 0

'

#

3

4 ++

3 F

F 4 $ F++

2 A

F

++

"

. / ( (2 ( # # ! ! ( ) ) +* *+ +* *+ ! +* *+ ( ) ) +* *+ +* *+ ! +* *+ ( ) ) ! +* *+ ! +* *+ ! ! +* *+ ! ( ) ) +* *+ +* *+ ! +* *+ , ,

(8)

#

. / ( - - - - -! - ,- -! -#-% - -%-' ,- ,-, ( ) ) +* *+ +* *+ ! +* *+ ( ) ) +* *+ +* *+ ! +* *+ ( ) ) ! +* *+ ! +* *+ ! ! +* *+ ! ( ) ) +* *+ +* *+ ! +* *+ , ,

+

>A . / ( >A >A (2 ( # # 3 2 2 4 # 2 ++ 3 4 # ++ 3 2 G >A 2 ) , ( ( >A 2 ) , , , ,

1 0 0 0

0 1 0 0

0 0 1 0

0 0 0 1

&

• Como somar duas matrizes:

– A[n][m]

– B[n][m]

– C=A+B

&

. ;( (2 1 (2 9 (2 55 ( H I) ; . ; D F 55 ( H I) ; . ; 1 D1 F ! 3 4 ++ 3 F F 4 F ++ F 1 F ! , ( ) ) *. 6 J >K 9* 3 4 ++ 3 F F 4 F ++ 9 F F + 1 F ( ) ) 9 F + * * , ( ) ) ,

(9)

%

• Escreva um programa em Java para calcular

o mínimo e o máximo valor numa matriz.

%

L . ; (2 ! ! -/--F ( ) ) *. ; > D* 3 4! ++ 3 F F4! F++ ; F . )3 . ) 0 ( ) ) ; F + * * , ( ) ) , ( ) ) 55 3 ; 55 M ; / 8 55 / ( ( 8 55 ( ( ( 3 4! ++ 3 F F4! F++ 3 ; F 4 ; F / F , , ( ) ) *. >< >. @ . : 7@ E * + + * ( ( *+/+*-*+ +* * ( ) ) , ,

// Determinar qual a classificação mais alta da tabela. // Assume-se que as notas já foram introduzidas na tabela.

float tabela[][] = new float[40][4]; // 40 alunos, 4 testes

floatnotaMax = tabela [0][0]; intlin = 0, col = 0; for(inti=0; i < tabela.length; i++)

for(intj=0; j < tabela [0].length; j++) if(tabela [i][j] > notaMax) {

notaMax = tabela [i][j]; lin = i; col = j }

System.out.println ("Nota máxima "+notaMax); System.out.println ("Obtida pelo aluno "+lin); System.out.println ("No teste "+col); }

,

$

• Declaração de uma matriz tri-dimensional 10x10x10:

int Mat3D [][][] = new int[10][10][10];

(10)

((A . / ((A (2 # $ -F-N 3 4 ++ 3 F F4# F++ 3 N N4$ N++ ((A F N 0 F 0 N 3 4 ++ 3 F F4# F++ 3 N N4$ N++ ( ) ) ((A F N + * * ( ) ) , ( ) ) , , ,

&

9 (2 $ 1 (2 $ 9 (2 $ 3 4 ++ 3 F F 4 F++ 3 N N 4 $ N++ F N 1 F N ! , ( ) ) *9@ 1 B 9* 3 4 ++ 3 F F 4 F++ 3 N N 4 $ N++ 9 F N F N + 1 F N ( ) ) 9 F N + * * , ( ) ) , , ,

%

-

.

-( -( )0 L ( L . ( ! ( ) ) *> ; $ O ( D* / (2 $ 55 ( ( ( $ 3 4 /)( ++ 55 P $ ( ( / =( ) ( > + / , ( ( 5 ( /)( 55 M ( ) ) * M * + ( ( ( . ) ( 8 / ( 3 4 /)( ++ ( . ) ( 8 / 3 Q ( ( ( , , ( ) ) *< O ( ( M D* + / ( , ,

(11)

/

Uma empresa de betão tem 3 fábricas (F1, F2, F3) que devem fornecer 3 obras de construção (O1, O2, O3). Os custos por transporte de uma carga de cada fábrica para cada obra são os representados na seguinte matriz:

Considere agora que as 3 fábricas podem produzir 4, 12 e 8 cargas por dia e as obras precisam de 10, 9 e 5 cargas por dia, respectivamente. Suponha agora que o gestor das fábricas propõe o seguinte esquema de transporte representado na matriz seguinte: 24 10 7 35 18 17 10 12 3 3 2 1 F F F 5 3 0 0 6 6 0 0 4 3 2 1 F F F 3 2 1O O O 3 2 1O O O

/

• Calcule o custo do esquema proposto.

• Escreva um programa em Java para calcular

o custo deste cenário de transporte.

&

( ( )0 ( ( - ! - ,- & - " - $ ,- & - -! # ,, ( ( R ( # - - ,- % -% - ,- - -$ ,, 3 4 ()( ++ 3 F F 4 ( )( F++ + ( F 0 ( R ( F ( ) ) *9 ( *+ , ,

%

"

• Escreva um programa em Java que leia uma

matriz de um ficheiro em disco

“matriz.txt”.

• O programa deve indicar se é uma matriz

identidade ou não.

1 0 0 0

0 1 0 0

0 0 1 0

0 0 0 1

4

(12)

%

"0

• Escreva um programa em Java que leia duas

matrizes de dois ficheiros em disco

“mat_A.txt” e “mat_B.txt”.

• O programa deve indicar se as duas matrizes

são iguais ou diferentes. Se forem diferentes

deve indicar quantos são os valores

diferentes.

1 2 3 4 4 5 6 7 7 8 9 0 0 1 2 3 1 2 3 4 4 5 6 7 7 8 9 0 0 1 2 3 1 2 3 4 4 5 5 7 7 1 9 0 0 1 2 3 4 4 4

%

#

• Escreva um programa em Java que verifique

se uma matriz A[N][N] é ou não uma matriz

simétrica.

1 2 3 4

2 5 6 7 3 6 9 0 4 7 0 3

• Caso não seja uma matriz simétrica deve

inverter a matriz da seguinte forma:

1 2 2 2 5 4 2 2 5 5 4 2 5 5 5 4 1 5 5 5 2 4 5 5 2 2 4 5 2 2 2 4

• A =

B =

• C = A x B =

• C

_ij

= A

_ikx

B

_kj

com m igual ao número de colunas de A. = m k 1 + + + + 4 * 4 2 * 3 3 * 4 1 * 3 4 * 2 2 * 1 3 * 2 1 * 1 y x y x y x y x y x y x y x y x 4 3 2 1 x x x x 4 3 2 1 y y y y 4 3 2 1 −1 0 6 5 14 15 4 5

x

=

5 = 1x5 + 2x0 ( -!,- -#,, ( 1 $-%,- -8 ,, )( 55 O ( ( ; )( 55 O ( ( ; ( ( ( O ( ( ( 1 1 )( 55 O ( ( ( 1 ( : (2 ( 3 4 ++ 3 F F 4 F++ 9 F 3 N N 4 N++ 9 F + N 01 N F , , 3 4 9)( ++ 3 F F 4 9 )( F++ ( ) ) 9 F + *S * ( ) ) , , ,

(13)

1 /

2 &

1 • Será que cada número par é igual à soma de dois

números primos?

• Verifique com a tabela de primos em baixo (N >= 8 até 52)

• Exemplos: 12 = 5 + 7

28 = ... + ...

40 = ... + ...

52 = ... + ...

( ! - -$ -& - - - & - ' -! -! ' - - & -# -# ,

&

public class prime_even{ public static void main(String args[]){

int primes[] = {2,3,5,7,11,13,17,19,23,29,31,37,39,41,43,46}; int i,j,soma;

boolean found=false; for(int N=8; N < 54; N=N+2){

//testa os primeiros 50 pares found = false; i = 0;

while((!found) && (i < primes.length)){ j = 0;

while((!found) && (j < primes.length)){ if(i != j){

soma = primes[i] + primes[j]; if(soma == N){

found = true;

System.out.println(N+" = "+primes[i]+" + "+primes[j]); } } j++; }// 2o while i ++; } // 1o while } } }

3 • Considere que tem uma tabela de 10 inteiros

que é inicializada com valores aleatórios:

(2

55 ;(

(

3

4 ++

.

)

0 ,

• Escreva um programa para ordenar esta

tabela.

3

(2 55 ;( ( 3 4 ++ . ) 0 , 55 ( T ( ( ) ) *1 (3 ( D* 3 4 ++ ( ) ) * *+ +* * + , ( ( 3 ( 55 ( 2 ( G ( ( ( 3 4 ' ++ 3 Q + ( + + ( ( 3 ( , , , 55 ( ( ( ) ) ( ) ) * 3 ( D* 3 4 ++ ( ) ) * *+ +* * + , , ,