Arrays

Um array é um grupo de variáveis do mesmo tipo que são referenciadas por

um nome comum. Podemos criar arrays de qualquer tipo, e eles podem ter uma
ou mais dimensões. Um elemento específico de um array é acessado por seu
índice. Os arrays representam uma forma prática de agrupar elementos
correlacionados do mesmo tipo.

Logo no início, precisamos dar um aviso aos programadores C/C++: Em

Java, os arrays funcionam de forma bastante diferente dos arrays de C/C++. Um
array unidimensional é essencialmente uma lista de variáveis do mesmo tipo. Para
criar um array, primeiro criamos uma variável array do tipo desejado. Por exemplo,
a linha a seguir:

int vet [ ] ;

Cria uma variável array do tipo int chamada vet.

Aqui, o tipo int declara o tipo básico do array. O tipo básico determina o tipo
de dados de cada elemento que forma o array. Ou seja, o tipo básico do array
determina o tipo dos dados que o array conterá. No caso, a linha anterior cria uma
variável array de ints. Embora esta declaração estabeleça o fato de que vet é uma
variável array, ainda não existe um array de fato neste ponto. Na verdade, o valor
de vet é automaticamente ajustado para null, que representa um array sem
nenhum valor.

Para conectar vet a um array físico e real de inteiros, é preciso alocá-lo,

usando new e atribuí-lo a vet (new é um operador especial que aloca memória).
Examinaremos new com mais detalhes em uma próxima disciplina do nosso
curso, mas precisamos usá-lo agora para alocar memória para arrays. Eis a forma
como new é usado para alocar um array de 10 ints:

vet = new int [ 10 ] ;

Observe que, nesta linha, o array de ints recém-alocado está sendo

atribuído à variável vet. Aqui, int especifica o tipo de dados que estão sendo
alocados. O número 10 entre colchetes [ ] especifica o número de elementos
contidos no array. E vet é a variável array à qual o array recém-alocado é
conectado.

Resumindo: quando usamos new para alocar um array, precisamos

especificar o tipo e o número de elementos a alocar. Os elementos do array
alocado por new serão automaticamente inicializados com o valor zero.

Mais uma vez: a obtenção de um array é um processo em duas etapas.

Primeiro, é preciso declarar uma variável do tipo array desejado. Segundo, é
preciso alocar a memória que conterá o array usando new e atribuí-la à variávvel
do array. Assim;em Java;todos os arrays; são alocados dinamicamente.

Uma vez que você tanha alocado um array; é possível acessar um

elemento específico do array marcando seu índice dentro dos colchetes. Todos os
índices de arrays começam em zero. Por exemplo, a linha que se segue atribui o
valor 5 ao segundo elemento de vet:

vet [ 1 ] = 5 ;

A próxima linha exibe o valor armazenado no índice 3:

JOptionPane.showMessageDialog(null, (int) vet[3]);

Parar ilustrar esses conceitos, eis um programa que cria um array e logo
depois inverte os valores de cada índice dentro do mesmo array:

1. import javax.swing.JOptionPane;
2. public class ArrayUni
3. {
4. public static void main (String args [ ] )
5. {
6. int vet[] = new int [10] ;
7. int aux ;
8. vet [0] = 2;
9. vet [1] = 5;
10. vet [2] = 9;
11. vet [3] = 6;
12. vet [4] = 8;
13. vet [5] = 10;
14. vet [6] = 1;
15. vet [7] = 11;
16. vet [8] = 4;
17. vet [9] = 12;
18. JOptionPane.showMessageDialog(null, "O vetor original é este : \n") ;
19. for (int i=0; i < 10; i ++ )
20. JOptionPane.showMessageDialog(null, vet[i] + " \t " ) ;
21. // calcula o vetor invertido
22. for ( int i=0; i<5; i++)
23. {
24. aux=vet [i];
25. vet [i] = vet [9 - i] ;
26. vet [9 - i] = aux ;
27. }
28. JOptionPane.showMessageDialog(null, "O vetor invertido é este : \n"
);
 29. for (int i=0; i<10; i ++)
30. JOptionPane.showMessageDialog(null, vet [i] + " \t " );
31. } // fim do método main ( )
32. } // fim da classe ArrayUni.java

A saída gerada por este programa é:

O vetor original é este:

2 5 9 6 8 10 1 11 4 12

O vetor invertido é este:

12 4 11 1 10 8 6 9 5 2

Os arrays podem ser inicializados no momento da declaração. O processo

é muito parecido com aquele usado para inicializar tipos simples. Um inicializador
de array é uma lista de expressões separadas por vírgulas contidas entre chaves {
}.

As vírgulas separam os valores dos elementos do array. O array será

automaticamente criado com o tamanho certo para conter o número de elementos
especificados no inicializador do array. Não há necessidade de usar new. O
próximo exemplo é uma nova versão do programa ArrayUni.java:

1. import javax.swing.JOptionPane;
2. public class ArrayUni2
3. {
4. public static void main (String[ ] args )
5. {
6. int vet[] = {2,5,9,6,8,10,1,11,4,12} ;
7. int aux;
8. JOptionPane.showMessageDialog(null, "O vetor original é este : \n") ;
9. for (int i=0; i < 10; i ++ )
10. JOptionPane.showMessageDialog(null, vet[i] + " \t " ) ;
11. // calcula o vetor invertido
12. for ( int i=0; i<5; i++)
13. {
14. aux=vet [i];
15. vet [i] = vet [9 - i] ;
16. vet [9 - i] = aux ;
17. }
18. JOptionPane.showMessageDialog(null, "O vetor invertido é este : \n" ) ;
19. for (int i=0; i<10; i ++)
20. JOptionPane.showMessageDialog(null, vet [i] + " \t " );
21. } // fim do método main ( )
22. } // fim da classe ArrayUni2.java
Ao ser executado, este programa gera a mesma saída da versão anterior.

O vetor original é este:

2 5 9 6 8 10 1 11 4 12

O vetor invertido é este:

12 4 11 1 10 8 6 9 5 2

Observe ns linha 6 que, já ao ser criado, o array de inteiros é inicializado

com um número. Java faz uma rigorosa checagem para assegurar que o
programador não tente armazenar ou referenciar valores fora do alcance do array.
O sistema runtime de Java faz a checagem para ter certeza de que todos os
índices de array estejam dentro da faixa correta. Neste aspecto, Java é
fundamentalmente diferente de C/C++, que não faz limites em tempo de
execução. Por exemplo, o sistema runtime faz a checagem do valor de cada
índice do array vet para assegurar que todos estejam dentro da faixa 0 a 9,
inclusive se tentarmos acessar um elemento fora do alcance do array, usando um
número negativo ou um número maior que o comprimento do array, isso causará
um erro em tempo de execução.