1. Array — um contêiner de elementos
Muito provavelmente você já ouviu que computadores podem processar enormes volumes de informação. O operador condicional (if-else) e os laços (for, while) certamente ajudam nisso. Mas não vamos muito longe apenas com eles, pois os dados a serem processados precisam ser armazenados de alguma forma.
Para isso, em Java, assim como praticamente em todas as linguagens de programação, existe uma estrutura excelente: os arrays (Array). Eles também são chamados de contêineres.
Um array é um objeto especial no qual é possível armazenar não apenas um valor, mas vários.
Se antes comparávamos uma variável a uma caixa (onde podemos armazenar algum valor), então um array é mais como uma caixa dividida em seções. Cada seção na “caixa-array” tem seu número. A numeração, claro, começa em zero...
Podemos fazer outra analogia. Vamos comparar uma casa comum e um prédio. Uma casa comum é ocupada por uma única família, enquanto um prédio é dividido em apartamentos. Para enviar uma carta a uma família que mora numa casa, é preciso indicar seu endereço único. Já para enviar uma carta a uma família que mora em um apartamento, é necessário indicar o endereço único do prédio e também o número do apartamento.
Assim, uma variável-array é como um “prédio”. Nela, podemos armazenar não um valor, mas vários. Essa variável tem vários “apartamentos” (posições), e cada um pode ser acessado pelo seu número (índice).
Para isso, após o nome da variável, entre colchetes, devemos indicar o índice da posição à qual estamos acessando. É bem simples:
array[indeks] = znachenie;Onde array é o nome da variável-array, indeks é o número da posição no array, e znachenie é o valor que queremos armazenar naquela posição.
Mas vamos, antes de tudo, entender como criar arrays.
2. Criação de um array de elementos em Java
Suponha que seu programa precise armazenar 100 números inteiros. Muito provavelmente, um array serviria para isso. E como criá-lo?
Se quiséssemos armazenar um único número inteiro, o tipo int serviria. Mas, se queremos armazenar 100 números inteiros, provavelmente precisamos de um array do tipo int. Veja como fica o código para criá-lo:
int[] array = new int[100];Vamos entender o que está escrito aqui.
Como você já deve ter percebido, à esquerda do sinal de igualdade temos a declaração da variável de nome array e do tipo int[]. Após o tipo int vêm os colchetes, que indicam que nas “caixas” desse tipo poderemos armazenar não um valor, mas vários.
À direita do sinal de igualdade temos a “criação de objeto” (a palavra new) com 100 elementos (posições) do tipo int. Também não é nada complicado.
Se quiséssemos, por exemplo, criar um array com 20 posições para armazenar números de ponto flutuante, o código de criação ficaria aproximadamente assim:
double[] vals = new double[20];O número de posições em um array é chamado de tamanho do array ou comprimento do array. Pela capacidade de armazenar muitos valores, arrays também são chamados de contêineres.
Fato importante: o tamanho do contêiner (array) não pode ser alterado após a criação.
Você pode criar um novo, mas o comprimento de um contêiner já criado não pode ser mudado.
3. Trabalhando com os elementos do array
Muito bem, aprendemos a criar arrays; como trabalhar corretamente com eles?
Praticamente do mesmo jeito que com variáveis comuns, mas após o nome da variável-array é obrigatório indicar o número da posição com a qual estamos trabalhando.
A numeração das posições do array sempre começa em zero. Se temos um array com 10 elementos, então os números (índices) de suas posições são 0..9; se o array tem 200 elementos, então 0..199. E assim por diante.
Exemplos:
int[] a = new int[10]; // Criamos um array de 10 elementos do tipo int.
a[2] = 4; // Gravamos o valor 4 na posição (índice) 2.
a[7] = 9; // Gravamos o valor 9 na posição (índice) 7.
a[9] = a[2] + a[5]; // Na posição (índice) 9, gravamos a soma dos valores armazenados nas posições 2
// (4) e 5 (0).
Veja o que ficará na memória após a execução desse código:
A coluna à esquerda do array (em cinza) são os números (índices) das posições. Nas posições ficam os valores gravados: 4, 9 e 4. Logo após a criação, as posições do array são preenchidas com zeros.
Importante. Todas as posições de um array têm o mesmo tipo de dados. Se criarmos um array de strings String, em suas posições só poderemos armazenar strings. O tipo de dados do array é definido na sua criação. Nem o tipo de dados nem o comprimento do array podem ser alterados posteriormente.
4. Arrays na memória
As imagens nos exemplos anteriores são um pouco inexatas.
Ao criar arrays (assim como ao criar strings), são alocados dois blocos de memória: um para armazenar o próprio array (o contêiner) e outro para a variável que armazena seu endereço. A situação ajustada está ilustrada na figura abaixo:
Em verde, temos um array com 10 elementos do tipo int e uma variável do tipo int[] que armazena o endereço (referência) do array do tipo int na memória.
Para comparação, em azul está uma variável comum do tipo int, que armazena o valor 199.
Lembra o armazenamento de strings na memória, não acha?
Exato, strings. E, assim como com strings, “variáveis do tipo array” podem ser atribuídas umas às outras:
int[] a = new int[10]; // Criamos um array de 10 elementos do tipo int.
a[2] = 4; // Gravamos o valor 4 na posição (índice) 2.
a[7] = 9; // Gravamos o valor 9 na posição (índice) 7.
int[] b = a; // A variável b recebe o mesmo endereço que está na variável a.
// Agora a e b apontam para o mesmo objeto-array na memória.
a[9] = b[2] + a[7]; // Na posição (índice) 9 do objeto-array, gravamos a soma dos valores
// armazenados nas posições 2 (4) e 7 (9).
Nesse processo, o objeto-array continuará onde está, e as variáveis a e b armazenarão o mesmo endereço (referência) para o mesmo objeto. Veja a figura:
5. Trabalhando com arrays em mais detalhes
É possível criar um array de absolutamente qualquer tipo. Para isso, basta escrever colchetes após o nome do tipo. A forma geral de criação de um array é a seguinte:
tip[] imya = new tip[kolichestvo];Onde tip é o tipo dos elementos (posições) do array que vamos armazenar. imya é o nome da variável pela qual acessaremos o array, e kolichestvo é a quantidade de posições no array.
No exemplo acima está a forma canônica: criação da variável-array e criação do objeto-array. Na verdade, são duas construções independentes. É possível criar a variável-array e o objeto-array separadamente:
tip[] imya;
imya = new tip[kolichestvo];E mais um ponto importante
Tanto o índice do array quanto a quantidade de elementos do array podem ser variáveis ou até expressões inteiras.
Exemplos:
int n = 100;
int[] a = new int[n]; // Criação de um array de n elementos
int n = 100;
int[] a = new int[n * 2 + 3]; // Criação de um array com 203 elementos
int n = 100;
int[] a = new int[n];
a[n-1] = 2; // a[99] = 2;
a[n-2] = 3; // a[98] = 3;
a[n/5] = a[n-1] + a[n-2] // a[20] = a[99] + a[98];
Acesso fora dos limites do array
Aliás, atenção: se você tentar acessar uma posição cujo índice não existe no array (no nosso caso, todos os inteiros exceto 0..99), o programa encerrará com o erro ArrayIndexOutOfBoundsException — índice fora dos limites do array.
6. Comprimento do array
Como vimos no exemplo anterior, é possível criar a variável do tipo array separadamente e, depois, em algum ponto do código, atribuir a ela um valor (uma referência a um objeto-array). Podemos até fazer assim:
int[] array; // Criamos uma variável-array do tipo int[]
if (a < 10) // Se a variável a for menor que 10,
array = new int[10]; // então crie um array de 10 elementos.
else // Caso contrário
array = new int[20]; // crie um array de 20 elementos
E como trabalhar com esse array depois? Como saber quantos elementos há nele?
Para isso, o array tem uma propriedade (variável) especial — length. É possível obter o comprimento do array com a seguinte expressão:
array.length;Onde array é o nome da variável-array, e length é o nome da propriedade do objeto-array. O valor da propriedade length não pode ser alterado: você pode atribuir length a outras variáveis, mas não pode atribuir nada a length (o programa simplesmente não compilará).
Veja como podemos continuar o exemplo anterior:
int[] array; // Criamos uma variável-array do tipo int[]
if (a < 10) // Se a variável a for menor que 10,
array = new int[10]; // então crie um array de 10 elementos.
else // Caso contrário
array = new int[20]; // crie um array de 20 elementos
for (int i = 0; i < array.length; i++) // Laço por todos os elementos do array: de 0 até array.length − 1
{
System.out.println(array[i]);
}
7. Fatos sobre arrays em Java
Vamos resumir os fatos conhecidos sobre arrays:
- Fato 1. Um array é composto por várias posições (células).
- Fato 2. O acesso a uma posição específica é feito informando seu número (índice).
- Fato 3. Todas as posições são do mesmo tipo.
- Fato 4. O valor inicial de todas as posições é 0 e null (se a posição armazena um endereço), false (para o tipo boolean).
- Fato 5. String[] list é apenas a declaração de uma variável: o contêiner (objeto-array) ainda não foi criado. Para poder usá-lo, é preciso criar o array (contêiner) e atribuí-lo a essa variável; só então utilizá-lo. Veja o exemplo abaixo.
- Fato 6. Quando criamos um objeto-array (contêiner), precisamos indicar qual é o seu comprimento — quantas posições ele tem. Isso é feito com o comando: new TypeName[n];
- Fato 7. O comprimento do array pode ser obtido pela propriedade .length.
- Fato 8. Depois de criado, não é possível alterar nem o tipo de seus elementos nem sua quantidade.
String s; // s é igual a null
String[] list; // list é igual a null
list = new String[10]; // A variável list armazena a referência para o objeto — um array de strings com 10 elementos.
int n = list.length; // n é igual a 10
list = new String[0]; // Agora list contém um array com 0 elementos.
// O array existe, mas não pode armazenar elementos.
list = null;
System.out.println(list[1]); // Um erro será gerado — o programa terminará abruptamente.
// list contém uma referência vazia — null
list = new String[10];
System.out.println(list[10]); // Um erro será gerado — acesso fora dos limites do array.
// Se list contém 10 elementos/posições, os índices permitidos são: 0 1 2 3 4 5 6 7 8 9 — ao todo 10.
GO TO FULL VERSION