Contents
O problema
Dentro de um bloco, podemos declarar diversas variáveis e usá-las:
|
1 2 3 4 |
double saldoDaConta1 = conta1.getSaldo(); double saldoDaConta2 = conta2.getSaldo(); double saldoDaConta3 = conta3.getSaldo(); double saldoDaConta4 = conta4.getSaldo(); |
Isso pode se tornar um problema quando precisamos mudar a quantidade de variáveis a serem declaradas de acordo com um parâmetro. Esse parâmetro pode variar, como por exemplo, a quantidade de número contidos num bilhete de loteria. Um jogo simples possui 6 números, mas podemos comprar um bilhete mais caro, com 7 números ou mais.
Para facilitar esse tipo de caso podemos declarar um vetor (array) de doubles:
|
1 |
double[] saldosDasContas; |
O double[] é um tipo. Uma array é sempre um objeto, portanto, a variável saldosDasContas é uma referência. Vamos precisar criar um objeto para poder usar a array. Como criamos o objeto-array?
|
1 |
saldosDasContas= new double[10]; |
O que fizemos foi criar uma array de double de 10 posições e atribuir o endereço no qual ela foi criada. Podemos ainda acessar as posições do array:
|
1 |
saldosDasContas[5] = conta5.getSaldo(); |
O código acima altera a sexta posição do array. No Java, os índices do array vão de 0 a n-1, onde n é o tamanho dado no momento em que você criou o array. Se você tentar acessar uma posição fora desse alcance, um erro ocorrerá durante a execução.
No caso do bilhete de loteria, podemos utilizar o mesmo recurso. Mais ainda, a quantidade de números do nosso bilhete pode ser definido por uma variável. Considere que n indica quantos números nosso bilhete terá, podemos então fazer:
|
1 |
int[] numerosDoBilhete = new int[n]; |
E assim podemos acessar e modificar os inteiros com índice de 0 a n-1.
Arrays de referências
É comum ouvirmos “array de objetos”. Porém quando criamos uma array de alguma classe, ela possui referências. O objeto, como sempre, está na memória principal e, na sua array, só ficam guardadas as referências (endereços).
|
1 2 |
ContaCorrente[] minhasContas; minhasContas = new ContaCorrente[10]; |
Quantas contas foram criadas aqui? Na verdade, nenhuma. Foram criados 10 espaços que você pode utilizar para guardar uma referência a uma ContaCorrente. Por enquanto, eles se referenciam para lugar nenhum (null). Se você tentar:
|
1 |
System.out.println(minhasContas[0].getSaldo()); |
Um erro durante a execução ocorrerá! Pois, na primeira posição da array, não há uma referência para uma conta, nem para lugar nenhum. Você deve popular sua array antes.
|
1 2 3 |
ContaCorrente contaNova = new ContaCorrente(); contaNova.deposita(1000.0); minhasContas[0] = contaNova; |
Ou você pode fazer isso diretamente:
|
1 2 |
minhasContas[1] = new ContaCorrente(); minhasContas[1].deposita(3200.0); |
Uma array de tipos primitivos guarda valores, um array de objetos guarda referências.
Mas e se agora quisermos guardar tanto Conta Corrente quanto Conta Poupança? Um array de Conta Corrente só consegue guardar objetos do mesmo tipo. Se quisermos guardar os dois tipos de conta, devemos criar um array de Conta!
|
1 2 3 |
Conta[] minhasContas = new Conta[10]; minhasContas[0] = new ContaCorrente(); minhasContas[1] = new ContaPoupanca(); |
Perceba que não estamos criando um objeto do tipo Conta, que é abstrata, estamos criando 10 espaços que guardam referências para qualquer tipo de conta.
Percorrendo uma array
Percorrer um array é muito simples quando fomos nós que a criamos:
|
1 2 3 4 5 6 7 8 9 |
public static void main(String[] args) { int[] idades = new int[10]; for (int i = 0; i < 10; i++) { idades[i] = i * 10; } for (int i = 0; i < 10; i++) { System.out.println(idades[i]); } } |
Porém, em muitos casos, recebemos uma array como argumento em um método:
|
1 2 3 4 5 6 |
public void imprimeArray(int[] array) { // não compila!! for (int i = 0; i < ????; i++) { System.out.println(array[i]); } } |
Até onde o for deve ir? Toda array em Java tem um atributo que se chama length, e você pode acessá-lo para saber o tamanho do array ao qual você está se referenciando naquele momento:
|
1 2 3 4 5 6 7 |
public void imprimeArray(int[] array) { for (int i = 0; i < array.length; i++) { System.out.println(array[i]); } } |
Arrays não podem mudar de tamanho
A partir do momento que uma array foi criada, ela não pode mudar de tamanho.
Se você precisar de mais espaço, será necessário criar uma nova array e, antes de se referir ela, copie os elementos da array velha.
Percorrendo uma array no Java 5.0
O Java 5.0 traz uma nova sintaxe para percorremos arrays (e coleções, que veremos mais a frente).
No caso de você não ter necessidade de manter uma variável com o índice que indica a posição do elemento no vetor (que é uma grande parte dos casos), podemos usar o enhanced-for.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class AlgumaClasse{ public static void main(String[] args) { int[] idades = new int[10]; for (int i = 0; i < 10; i++) { idades[i] = i * 10; } // imprimindo toda a array for (int x : idades) { System.out.println(x); } } } |
Não precisamos mais do length para percorrer matrizes cujo tamanho não conhecemos:
|
1 2 3 4 5 6 7 |
public class AlgumaClasse { public void imprimeArray(int[] array) { for (int x : array) { System.out.println(x); } } } |
O mesmo é válido para arrays de referências. Esse for nada mais é que um truque de compilação para facilitar essa tarefa de percorrer arrays e torná-la mais legível.