Arrays em Java: declarar, inicializar, acessar e percorrer

Um array é uma lista de tamanho fixo

Um array em Java guarda um número fixo de valores do mesmo tipo, dispostos em ordem e acessados pela posição. "Fixo" é a palavra-chave: depois que você cria um array, o tamanho dele nunca muda. E "mesmo tipo": um int[] guarda apenas valores int, um String[] guarda apenas strings. Essa rigidez é o preço que se paga para que os arrays sejam rápidos e compactos na memória.

Você declara um tipo de array colocando [] depois do tipo do elemento e, em seguida, atribui um literal ou aloca um com new:

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};
        String[] names = {"Ada", "Boris", "Chen"};

        System.out.println(scores[0]);
        System.out.println(names[1]);
    }
}

Os colchetes podem ficar depois do tipo (int[] scores) ou depois do nome (int scores[]). Ambos compilam, mas int[] scores é o estilo idiomático de Java - coloque os [] junto ao tipo, onde eles pertencem.

Criando um array com new

Quando você ainda não conhece os valores mas conhece o tamanho, use new. Isso aloca as posições e as preenche com o valor padrão do tipo:

public class Main {
    public static void main(String[] args) {
        int[] nums = new int[5];
        boolean[] flags = new boolean[3];
        String[] words = new String[2];

        System.out.println(nums[0]);
        System.out.println(flags[0]);
        System.out.println(words[0]);
    }
}

Os valores padrão não são lixo aleatório - Java inicializa cada elemento com zero. Tipos numéricos começam em 0 (ou 0.0), boolean começa em false, e tipos de referência como String começam em null. Vale lembrar desse null: um String[] recém-alocado está cheio de nulls, e chamar um método em um deles lança um NullPointerException.

A indexação começa no zero

Você lê e escreve elementos pelo índice, contando a partir de 0. O último índice válido é sempre length - 1:

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        System.out.println(colors[0]);
        System.out.println(colors[2]);

        colors[1] = "yellow";
        System.out.println(colors[1]);
    }
}

Ao contrário dos arrays de algumas linguagens de script, sair do intervalo não devolve silenciosamente null nem undefined - lança uma exceção. Tente ler um índice que não existe:

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30};
        System.out.println(nums[5]);
    }
}

Esse programa quebra com:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 3

Esse é um dos erros mais comuns entre iniciantes. A correção quase sempre é um erro de um a mais (off-by-one) na condição de um laço - usar <= onde você queria <.

length é um campo, não um método

Todo array carrega seu tamanho em um campo length. Atenção: sem parênteses.

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40};
        System.out.println(nums.length);
    }
}

Aqui vai uma pegadinha que pega todo mundo pelo menos uma vez: arrays usam .length (um campo), mas String usa .length() (um método). Escrever nums.length() em um array é um erro de compilação, e escrever text.length em uma string também. A mesma palavra, regras diferentes - a do array não tem parênteses.

Percorrendo um array

Você aprendeu o laço for-each na página anterior, e ele é a forma mais limpa de ler cada elemento quando você não precisa do índice:

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};

        int total = 0;
        for (int score : scores) {
            total += score;
        }

        System.out.println("Total: " + total);
        System.out.println("Average: " + (total / scores.length));
    }
}

Quando você precisa do índice - para imprimir números de posição, modificar elementos no lugar ou iterar de trás para frente - recorra ao clássico laço for indexado usando length como limite:

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ada", "Boris", "Chen"};

        for (int i = 0; i < names.length; i++) {
            System.out.println(i + ": " + names[i]);
        }
    }
}

A condição é i < names.length, não <=. Usar <= avança um passo a mais e lança a exceção de fora do intervalo da seção anterior. Uma regra rápida: for-each quando você só lê valores, for indexado quando você precisa da posição ou quer escrever de volta no array.

Arrays multidimensionais

Um array 2D é, na verdade, um array de arrays - pense nele como uma grade de linhas e colunas. Você adiciona um segundo par de colchetes:

public class Main {
    public static void main(String[] args) {
        int[][] grid = {
            {1, 2, 3},
            {4, 5, 6}
        };

        System.out.println(grid[0][2]);
        System.out.println(grid[1][0]);

        for (int[] row : grid) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

grid[linha][coluna] seleciona uma única célula. Como cada linha é seu próprio array, grid.length é o número de linhas e grid[0].length é o número de colunas da primeira linha. As linhas nem precisam ter o mesmo tamanho (isso se chama array irregular, ou jagged), embora a maioria das grades seja retangular.

A classe utilitária Arrays

Os arrays em si quase não têm métodos - você não consegue ordenar nem imprimir um diretamente de forma útil. Java fornece uma classe utilitária java.util.Arrays cheia de auxiliares estáticos exatamente para isso:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {5, 2, 8, 1, 9};

        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

        int[] copy = Arrays.copyOf(nums, 7);
        System.out.println(Arrays.toString(copy));

        int found = Arrays.binarySearch(nums, 8);
        System.out.println("Index of 8: " + found);
    }
}

Algumas coisas em que se apoiar aqui. Arrays.toString(arr) é a forma certa de imprimir um array - imprimir um diretamente te dá uma string inútil como [I@1b6d3586. Arrays.sort ordena no lugar. Arrays.copyOf é como você "redimensiona": ele devolve um novo array com o tamanho que você pedir, preenchendo com valores padrão (as duas posições extras acima são 0). E Arrays.binarySearch só funciona corretamente em um array que já esteja ordenado.

Arrays vs ArrayList

Use um array simples quando o tamanho é conhecido de antemão e não vai mudar - um conjunto fixo de dias da semana, um tabuleiro de jogo, dados de pixels. Arrays são rápidos e leves, mas o tamanho fixo é uma limitação real: você não pode adicionar um sétimo elemento a um array de tamanho 6 sem construir um completamente novo.

No momento em que você precisa adicionar e remover itens livremente, um array fica desajeitado. É para isso que serve o ArrayList - uma lista redimensionável e expansível que cuida da cópia por você.

Próximo: ArrayList

Quando você não sabe quantos itens terá, ou esse número muda enquanto o programa executa, um array de tamanho fixo atrapalha. ArrayList é a resposta de Java: uma lista que cresce e encolhe sob demanda, com os métodos add e remove em vez de malabarismo com índices. É o que vem a seguir.