Como Obter o Comprimento de um Array em Java

Um array Java armazena seu tamanho permanentemente, e você lê esse tamanho através do campo length. Esta é uma das operações mais comuns que você realizará com arrays — para iterar sobre eles, encontrar o último elemento ou verificar se eles contêm algum dado. Este capítulo mostra como length funciona, como ele difere de String.length() e como medir arrays multidimensionais.

Use o campo length

Todo array em Java expõe um campo public final int length que contém o número de elementos. Você o lê sem parênteses, porque é um campo, não um método.

int[] scores = {88, 92, 75, 60, 100};
int size = scores.length;          // 5
System.out.println(scores.length); // 5

O valor é fixado quando o array é criado e nunca muda — arrays em Java não crescem nem encolhem. Se você precisar de uma coleção redimensionável, use ArrayList, que expõe size() como método. O campo length também funciona da mesma forma para arrays de qualquer tipo: String[], double[] ou mesmo um array de objetos.

Campo vs. método: length vs. length()

Uma fonte frequente de confusão é misturar arrays com strings. Um array usa o campo length; uma String usa o método length(). Escrever o errado não compilará.

int[] numbers = {1, 2, 3};
String text = "hello";

System.out.println(numbers.length);   // field, no ()  -> 3
System.out.println(text.length());    // method, with () -> 5

Uma regra simples: arrays são os únicos dos três que usam um campo puro. Todo o resto usa uma chamada de método.

Tratar casos de array vazio e último elemento

Um array criado com tamanho 0 é um objeto real e não nulo cujo length é 0. Isso é diferente de uma referência null, que não tem comprimento algum — ler .length em null lança NullPointerException. Para usar o tamanho com segurança, itere de 0 até length - 1, pois o último índice válido é sempre um a menos que o comprimento.

int[] empty = new int[0];
System.out.println(empty.length);          // 0, not an error

int[] data = {10, 20, 30};
int last = data[data.length - 1];          // 30
for (int i = 0; i < data.length; i++) {
    System.out.println(data[i]);
}

Se um array pode ser null, proteja-se primeiro: if (data != null && data.length > 0).

Medir arrays multidimensionais

Um array bidimensional em Java é na verdade um array de arrays. O length externo fornece o número de linhas, e cada linha tem seu próprio length para a contagem de colunas dessa linha. As linhas podem até ter comprimentos diferentes (um array irregular), portanto sempre leia o comprimento de cada linha individualmente em vez de assumir uma largura uniforme.

int[][] grid = {
    {1, 2, 3},
    {4, 5},
    {6, 7, 8, 9}
};
System.out.println(grid.length);     // 3 rows
System.out.println(grid[0].length);  // 3 columns in row 0
System.out.println(grid[2].length);  // 4 columns in row 2

Para contar todos os elementos, some o comprimento de cada linha em vez de multiplicar linhas por colunas — esse atalho só funciona para grades perfeitamente retangulares.

Exemplo prático

O programa abaixo reúne todas essas ideias: um array simples, a distinção campo-vs-método, um array vazio, acesso ao último elemento e um array 2D irregular cujo tamanho total é calculado somando os comprimentos das linhas.

O que observar na execução:

• scores.length = 5 confirma que length é lido como um campo puro sem parênteses e retorna a contagem de elementos.
• word.length() = 5 mostra que o tamanho de String vem do método length(), um mecanismo diferente do campo de array.
• empty.length = 0 prova que um array de comprimento zero é um objeto válido, não null, e ler seu comprimento é seguro.
• last element = 100 demonstra que o índice final é length - 1, pois a indexação começa em 0.
• grid.length (rows) = 3 enquanto grid[2].length é 4, mostrando que o comprimento externo conta linhas e cada linha carrega seu próprio comprimento — somado para total elements in grid = 9.

Prática