AULA TEÓRICA 8

Tema 5. Vectores e Matrizes

 Array unidimensional. Criação. Acesso aos elementos.
 Algoritmo de procura de valor maior/menor num array.
 Algoritmos de ordenação
 Array bidimensional

1
 Array unidimensional
Arrays de tipos de dados primitivos
Os programas que desenvolvemos até aqui têm usado as variáveis de todos os tipos
de dados de tamanho limitado. Num dado momento cada variável só pode conter um
único valor.
Mas existem casos quando a quantidade de valores a serem tratados é elevada. Para
isso podem ser utilizados arrays.
Criação
Um array é um objecto que contém uma lista de elementos do mesmo tipo e ocupa
um espaço na memória. Este conjunto de elementos é referenciado pelo um único
nome do array.
Para criar um array em primeiro lugar é necessário declarar a referência para o array.
Por exemplo, para declarar um array de notas de alunos:
byte notas[]; ou byte [] notas;
Uma vez obtida a referência, é possível criar o array. Todos os objectos em Java
(inclusive arrays) devem ser alocados dinamicamente com o operador new:
notas = new byte[50]; //aloca o espaço para array
Esta instrução cria um novo objecto com espaço para armazenar 50 números do tipo
byte. Os 50 elementos ficam em posições consecutivas na memória e o endereço
(é representado pelo símbolo @) do primeiro elemento fica armazenado na referência
notas. 2
 notas

@ @+1 @+2 @+3 @+4 ... @+48 @+49

O programador não terá que se preocupar com o endereço de memória onde fica cada
elemento do array, pois acesso será feito através de índices.
Para criar um array podemos unir as duas instruções:
byte notas[]= new byte[50];
O número entre parênteses rectos define o espaço de memória reservado para o array,
que não significa que o array tenha que conter sempre esse número de elementos,
podendo conter qualquer valor inferior, inclusivamente zero.
Por exemplo, a declaração do array notas poderia ter sido feita depois de solicitar ao
utilizador o número de notas a armazenar:
System.out.println("Intr. o número de notas a armazenar: ");
quant = Integer.parseInt(x.readLine());
byte notas[] = new byte[quant]; 3
Podemos alocar memória para vários arrays do mesmo tipo com uma única
declaração. A declaração seguinte reserva 100 elementos para o array b e 27
elementos para o array x cujos elementos são do tipo float:

float b[] = new float[100], x[] = new float[27];

Outra forma também é aceitável:
float[] b = new float [100], x = new float [27];

Java permite a criação e inicialização de um array usando uma forma abreviada, por
exemplo:
byte diasMes[] = {31,28,31,30,31,30,31,31,30,31,30,31};

Esta instrução cria um array com espaço suficiente para os dados fornecidos,
procedendo também à sua inicialização.
Comprimento do array
Todos os array em Java “conhecem” seu próprio comprimento e mantém essa
informação numa variável denominada length que guarda o número de elementos
com que o array foi criado.

Por exemplo:
byte[] notas = new byte[50];
System.out.println("Numero maximo de notas é "+notas.length);
4
Exemplo de armazenamento de informação num array de N inteiros:
import java.io.*;
public class CriarArray
{ public static void main(String args[])throws IOException
{ BufferedReader b =
new BufferedReader(new InputStreamReader(System.in));

System.out.println ("Quantos valores pretende introduzir: ");

int q = Integer.parseInt(b.readLine());
//cria array
int val[] = new int [q];

System.out.println ("intr. "+q+" valores inteiros: ");

for (int i=0; i < q; i++)
{ System.out.println((i+1)+"-o valor: ");
val[i] = Integer.parseInt(b.readLine());
}

//visualiza o conteudo do array

for (int j=0; j < val.length; j++)
System.out.print(val[j]+" " );
}
} 5
 Acesso aos elementos de array
O acesso a cada um dos elementos do array é feito usando um índice que
define a sua posição no array. O primeiro elemento tem o índice zero,
enquanto que o último elemento tem um índice igual ao número dos elementos
do array menos 1. Para o nosso exemplo os índices válidos vão de 0 a 49. Se
for necessário colocar o valor 14 no primeiro elemento do array e 12, no
segundo, pode fazer:
notas[0] = 14;
notas[1] = 12;
int soma = notas[0] + notas[1];
Exemplo do código que permita calcular a soma dos elementos de um array:
...
System.out.println ("Quantos são valores : ");
numElem = Integer.parseInt(k.readLine());
float [] tab = new float [numElem];
...
float soma = 0;
for (int z = 0; z < numElem; z++)
soma += tab[z];
System.out.println("Soma de "+numElem+"valores="+soma);
... 6
 Algoritmo de procura de valor maior / menor num array
Para encontrar o valor maior num array de inteiros poderia usar o método
seguinte:
. . .
float[] y = new float[100];
float maiorNum = y[0]; byte indice_do_maior = -1;
. . .
for (byte i=0; i < y.length; i++)
if (y[i] > maiorNum)
{ maiorNum = y[i];
indice_do_maior = i;
}
. . .
Para procura do valor menor usa-se a condição (<)

Ordenação por borbulhamento (Bubble sort)

Um problema fundamental em computação é a ordenação de dados. Existem
vários métodos de ordenação: por borbulhamento (bubble sort), por selecção
(selection sort), tipo Shell (shell sort), shaker sort, quick sort, etc.
A técnica usa dois ciclos for encadeados para fazer várias passagens pelo
7
array. O ciclo externo controla o número de passagens pelo array.
O ciclo interno controla as comparações e trocas (se são necessárias) dos
elementos durante cada passagem. Em cada passagem, pares de elementos
sucessivos são comparados: se um par estiver na ordem crescente (ou os
valores forem iguais), a bubble sort deixa os valores como estão, se um par
estiver na ordem decrescente, a bubble sort troca seus valores no array. O
algoritmo é muito simples, mas lento.
import java.util.Random;
public class ArrayOrdenacaoBubbleSort
{ public static void main (String args[])
{ //criação do array
int q = 200;
int v[] = new int [q];
Random r = new Random();
for (int i = 0; i < q; i++)
v[i] = r.nextInt(55); //gere números aleatorios
// inteiros na faixa de zero a 55

//visualização do conteúdo do array criado

System.out.println("Conteudo do array original:\n");
for (int k=0; k < v.length; k++)
System.out.print(v[k] + ", ");
8
 //ordenação
int aux;
for (int i = 1; i < v.length; i++ )
for (int j = 0; j < v.length-1; j++ )
if (v[j] > v[j+1])
{ aux = v[j];
v[j] = v[j+1];
v[j+1] = aux;
}

System.out.println("Conteudo do array ordenado:\n");

for (int k=0; k < v.length; k++)
System.out.print(v[k] + ", ");
}
}

9
 Array bidimensional
Um array unidimensional pode armazenar elementos de tipos simples e
também elementos que são objectos. Um caso particular quando cada
elemento de array é um array, criando-se assim um array bidimensional, ou
matriz, com linhas e colunas.
precos

[0] [1]

[0] precos[0][0] precos[0][1]

[1] precos[1][0] precos[1][1]

float precos[][];
precos = new float [3][2]; [2] precos[2][0] precos[2][1]
ou
float precos[][] = new float [3][2];
ou
float [][] precos={{120.54,100.34},{100.12,98.34},{157.89,180.12}};

10
Cada elemento do array bidimensional pode ser acedido através de dois
índices, um que indica a linha e outro a coluna.

Por exemplo, o elemento precos[2][1], de acordo com a ultima

declaração, possui o valor 180.12.

É possível obter:

o número de linhas dum array através de instrução:

int numLinhas = precos.length;
e o número de colunas dum array através de instrução:
int numColunas = precos[0].length;

Para aceder aos elementos do array deve se utilizar dois ciclos for, um
dentro do outro. O primeiro serve para fazer variar linhas e o segundo para
fazer variar colunas.

O exemplo a seguir preenche um array de 3 linhas e 2 colunas com valores

aleatórios, na faixa de 0 a 150, geridos pelo método nextInt() da classe
Random, visualiza o conteúdo do array no ecrã na forma de tabela e calcula a
soma de elementos que se encontram numa coluna escolhida pelo utilizador.
11
import java.util.Random;
import java.io.*;
public class ArrayBi
{
public static void main (String args[])throws IOException
{
int t[][] = new int [3][2];
Random r = new Random();
BufferedReader bb = new BufferedReader (new
InputStreamReader (System.in));
int soma = 0;

//armazena valores aleatorios na faixa de 0 a 150

for (byte i=0; i < t.length; i++)
for (byte j=0; j<t[0].length; j++)
t[i][j]= r.nextInt(150);

//visualiza na forma de tabela

for (byte i=0; i<t.length; i++)
{ for (byte j=0; j<t[0].length; j++)
System.out.print(t[i][j]+" ");
System.out.println();
} 12
//valida o número da coluna cujos valores pretende-se somar
int nc=0;
do
{ System.out.print("Soma de que coluna pretende(1-2)? ");
nc = Byte.parseByte(bb.readLine());
System.out.println(nc);
if (nc <= 0 || nc > t[0].length)
System.out.println("Num. de coluna invalida, deve ser
entre 1 e "+t[0].length);
} while (nc <= 0 || nc > t[0].length);

//calcula a soma de elementos da coluna escolhida

for (byte i = 0; i < t.length; i++)
soma += t[i][nc-1];

System.out.print("Soma de valores da coluna "+nc+

"="+soma);
}
} 13
TPC

Escrever um programa em Java para resolução do seguinte

problema:

 Armazenar quaisquer valores num array de N elementos.

Determinar a quantidade de números negativos existentes no
array. Visualizar o conteúdo do array criado.

 Multiplicar dois arrays de comprimento igual, criando um novo

3-o array. Conteúdo do 1-o são números aleatórios na faixa
de zero a cem. Conteúdo do 2-o são múltiplos de 5.

14
Referência bibliográfica:
António José Mendes; Maria José Marcelino.
“Fundamentos de programação em Java 2”. FCA. 2002.
Carriço, José; Carriço, António.
"Computadores, Tecnologias e sistemas de Informação- O Núcleo de Sistema“.
Centro de Tecnologias de Informação Ltd. Lisboa. 1997
Carriço, José; Carriço, António.
"Computadores, Tecnologias e sistemas de Informação- Periféricos, Internet e multimédia“.
Centro de Tecnologias de Informação Ltd. Lisboa. 1997.
Carriço, José; Carriço, António.
"Computadores, Tecnologias e sistemas de Informação- Tecnologias de Software“.
Centro de Tecnologias de Informação Ltd. Lisboa.1997.
Elliot Koffman; Ursula Wolz.
“Problem Solving with Java”. 1999.
John R. Hubbard.
“Theory and problems of programming with Java”. Schaum’s Outline series. McGraw-Hill.
H. Deitel; P. Deitel.
“Java, como programar”. 4 edição. 2003. Bookman.
Rui Rossi dos Santos.
“Programando em Java 2– Teoria e aplicações”. Axcel Books. 2004

15