Aula teórica 3

• Colecções. Array unidimensional.

• Comprimento do array
• Acesso aos elementos de array
• Array passado como parâmetro
• Algoritmo de procura de maior/menor valor
 Colecções – 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:
int notas[]; ou int[] 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 int [50]; //aloca o espaço para array
Esta instrução cria um novo objecto com espaço para armazenar 50 números
inteiros. 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
2
referência notas.
 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:
int[] notas= new int[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(z.readLine());
int[] notas = new int[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 byte :

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

Outra forma também é aceitável:
byte[] b = new byte[100], x = new byte[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:
int[] notas = new int[50];
System.out.println("Numero maximo de notas 4 é
"+notas.length);
 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;
Cada um dos elementos do array pode ser utilizado da mesma forma que uma
variável do tipo de elementos que o array guarda. Sendo notas um array de
valores do tipo int, qualquer elemento pode ser utilizado onde possa ser
usada uma variável do tipo int. Por exemplo:
 

int soma = notas[0] + notas[1];

 
Array passado como parâmetro
Array pode também ser passado como parâmetro para um método. Para isso
se especifique o nome do array (sem parênteses rectas []). Anteriormente,
vimos exemplo da classe CriarArray , onde no metodo main tem
instruçoes:
int[] ar = criarArray((byte)20);
5
visualizarArray(ar); //passagem do array
Exemplo de armazenamento de informação num array de inteiros:
import java.io.*;
public class CriarArray
{ public static int[] criarArray(byte q)throws IOException
{ BufferedReader y = new BufferedReader (new
InputStreamReader(System.in));
int[] val = new int[q];
System.out.println ("intr. "+q+" valores inteiros: ");
for (byte i = 0; i < q; i++)
{ System.out.println((i+1)+"-o valor: ");
val[i] = Integer.parseInt(y.readLine());
}
return val;
}

public static void visualizarArray(int[] m)

{ for (byte j = 0; j<m.length; j++)
System.out.print(m[j]+" " );
}

public static void main (String[] args)throws IOException

{ int[] ar = criarArray((byte)20);
visualizarArray(ar); 6
}}
Um outro exemplo é um método capaz de calcular e devolver a média dos
elementos de um array:
 
public static float calcularMedia(int[] tab,byte numElem)
{ float soma = 0; //tem que ser float para evitar a divisão de inteiros
for (byte z = 0; z < numElem; z++)
soma += tab[z];
return soma/numElem;
 
}
Para alem do array, este método recebe ainda como parâmetro o número de
elementos que este contém. A existência deste parâmetro torna este método
mais genérico, pois pode ser usado independentemente do array estar
preenchido ou não (nada obriga, a que um array tenha todos os elementos
preenchidos).
 

A chamada deste método no programa poderia ser assegurada pela instrução:

 

media = calcularMedia (notas, numNotas);

 

M Alterar um elemento de um array dentro de um método modifica o

conteúdo do array original, pelo que as alterações feitas ao array dentro
de um método se reflectem fora dele.
7
 Algoritmo de procura de valor maior / menor num array
Para encontrar o valor maior num array de inteiros poderia usar o método seguinte:
public static int procValorMaior(int[] y)
{ int maiorNum = y[0], indice_do_maior = 0;//neste caso tem que ser = 0
for (int i=0; i<y.length; i++)
if (y[i] > maiorNum) // para procura do valor menor usa a condição (<)
{ maiorNum = y[i];
indice_do_maior = i;
}
return indice_do_maior;//devolve a posição do elemento cujo valor é maior
}

8
Referência bibliográfica:
António José Mendes; Maria José Marcelino.
“Fundamentos de programação em Java 2”. FCA. 2002.
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