Arrays em Java

Um array em Java é um contêiner de tamanho fixo que armazena uma sequência de valores do mesmo tipo. Depois de criado, seu comprimento nunca muda, e cada posição pode armazenar exatamente um valor — um int, uma String, uma referência a qualquer objeto, qualquer coisa que caiba no tipo declarado.

Arrays são a base sobre a qual o restante das coleções Java (ArrayList, HashMap e outras) é construído. Eles não são tão ergonômicos quanto essas classes de nível superior, mas são rápidos, previsíveis e você os encontrará em todos os lugares — argumentos de métodos, valores de retorno, código sensível a desempenho.

Declarando um array

O tipo de um array é o tipo do elemento seguido de []:

int[] scores;       // an array of ints
String[] names;     // an array of String references
double[] prices;    // an array of doubles

Os colchetes também podem aparecer após o nome da variável — int scores[]; — mas a forma int[] scores é muito mais comum e é a que você deve usar.

Declarar uma variável ainda não cria um array; ela apenas fornece ao Java um slot que pode conter uma referência a um array. O slot começa como null.

Criando um array com new

Para de fato alocar o array, use new com um comprimento:

int[] scores = new int[5];

Isso reserva espaço para 5 ints. Java inicializa cada slot com o valor padrão do tipo:

• tipos numéricos → 0 (ou 0.0)
• boolean → false
• char → '�' (o caractere nulo, ponto de código 0 — não um espaço)
• tipos de referência → null

Portanto, scores imediatamente contém {0, 0, 0, 0, 0}. Não existe estado "não inicializado" — uma vez que você cria o array, cada posição tem um valor definido.

Literais de array

Quando você conhece o conteúdo antecipadamente, use um literal:

int[] scores = {90, 85, 73, 100, 62};
String[] colors = {"red", "green", "blue"};

O comprimento é inferido a partir do número de elementos. Esta forma só é válida na mesma linha da declaração — você não pode escrever scores = {90, 85}; depois. Para isso, use a forma explícita:

scores = new int[]{90, 85, 73, 100, 62};

Acessando elementos

Você lê e escreve elementos por índice baseado em zero, usando colchetes:

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores[0]);   // 90
System.out.println(scores[4]);   // 62
scores[2] = 80;                  // replace 73 with 80

Os índices válidos vão de 0 até length - 1. Um índice fora do intervalo lança ArrayIndexOutOfBoundsException em tempo de execução — Java não retorna silenciosamente um valor padrão nem faz um wraparound.

A propriedade length

Todo array tem um campo length público e somente leitura que informa seu tamanho:

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores.length);   // 5

Observe que é um campo, não um método — sem parênteses. Essa é uma das pequenas peculiaridades do Java: strings usam .length(), arrays usam .length. Eles também se comportam de maneira diferente das coleções (list.size()). As formas são fáceis de confundir; o compilador irá avisá-lo.

length é fixo na criação. Para "aumentar" um array você deve alocar um novo e copiar — veja o capítulo Copiando arrays.

Arrays armazenam referências, não cópias

Quando o tipo do elemento é um objeto, o array armazena referências, não os objetos em si:

String[] colors = {"red", "green", "blue"};
String first = colors[0];
// first and colors[0] both reference the same "red" string

Para primitivos essa distinção não importa — valores int são copiados para dentro e para fora. Para objetos, mutar um elemento de fora do array muda o que o array enxerga, porque eles compartilham a referência.

Valores padrão e arrays null

Uma variável de array declarada mas não atribuída é null, e ler .length ou qualquer índice nela lança NullPointerException:

int[] data;            // not initialized
// System.out.println(data.length);  // would throw NullPointerException
data = new int[3];
System.out.println(data.length);     // 3

Um array vazio — com comprimento zero — é um array perfeitamente válido, e geralmente é o que você quer para um valor de retorno "vazio", não null:

int[] none = new int[0];
System.out.println(none.length);     // 0

Um exemplo prático

Imprimindo um array

Uma surpresa comum: passar um array diretamente para System.out.println não exibe seu conteúdo. Ele imprime o tipo e o hash de identidade do array:

int[] scores = {90, 85, 73};
System.out.println(scores);   // e.g. [I@39ed3c8d  — not the values!

O [I significa "array de int", e a parte hexadecimal é um hash de identidade, não dados. Para ver os elementos, use Arrays.toString do pacote java.util:

import java.util.Arrays;

int[] scores = {90, 85, 73};
System.out.println(Arrays.toString(scores));   // [90, 85, 73]

Para arrays aninhados (multidimensionais), use Arrays.deepToString em vez disso.

O que vem a seguir

Você já sabe criar um array e acessá-lo por índice. O próximo passo é a iteração — visitar cada elemento por vez com loops em arrays, para que você não precise escrever scores[0], scores[1], scores[2] um por um.

Prática