Cómo Obtener la Longitud de un Array en Java

Un array en Java almacena su tamaño de forma permanente, y puedes leer ese tamaño a través del campo length. Esta es una de las operaciones más comunes que realizarás con arrays — para iterar sobre ellos, encontrar el último elemento, o comprobar si contienen algún dato. Este capítulo muestra cómo funciona length, en qué se diferencia de String.length(), y cómo medir arrays multidimensionales.

Usar el campo length

Todo array en Java expone un campo public final int length que contiene el número de elementos. Se lee sin paréntesis, porque es un campo, no un método.

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

El valor se fija cuando se crea el array y nunca cambia — los arrays en Java no crecen ni se reducen. Si necesitas una colección redimensionable, utiliza ArrayList en su lugar, que expone size() como método. El campo length también funciona de la misma manera para arrays de cualquier tipo: String[], double[], o incluso un array de objetos.

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

Una fuente frecuente de confusión es mezclar arrays con cadenas de texto. Un array usa el campo length; un String usa el método length(). Escribir uno incorrecto no 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

Una regla simple: los arrays son los únicos de los tres que usan un campo sin más. Todo lo demás usa una llamada a método.

Manejar arrays vacíos y acceder al último elemento

Un array creado con tamaño 0 es un objeto real y no nulo cuya length es 0. Eso es diferente de una referencia null, que no tiene longitud alguna — leer .length sobre null lanza NullPointerException. Para usar el tamaño de forma segura, itera desde 0 hasta length - 1, ya que el último índice válido siempre es uno menos que la longitud.

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]);
}

Si un array podría ser null, protégelo primero: if (data != null && data.length > 0).

Medir arrays multidimensionales

Un array bidimensional en Java es en realidad un array de arrays. La length exterior indica el número de filas, y cada fila tiene su propia length para el número de columnas de esa fila. Las filas incluso pueden tener longitudes diferentes (un array irregular), así que siempre lee la longitud de cada fila individualmente en lugar de asumir un ancho 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 los elementos, suma la longitud de cada fila en lugar de multiplicar filas por columnas — ese atajo solo funciona para cuadrículas perfectamente rectangulares.

Ejemplo práctico

El programa siguiente reúne todas estas ideas: un array plano, la distinción campo-vs-método, un array vacío, acceso al último elemento, y un array 2D irregular cuyo tamaño total se calcula sumando las longitudes de cada fila.

Qué extraer de la ejecución:

• scores.length = 5 confirma que length se lee como un campo sin paréntesis y devuelve el número de elementos.
• word.length() = 5 muestra que el tamaño de String proviene del método length(), un mecanismo distinto al campo del array.
• empty.length = 0 demuestra que un array de longitud cero es un objeto válido, no null, y que leer su longitud es seguro.
• last element = 100 demuestra que el índice final es length - 1, ya que la indexación comienza en 0.
• grid.length (rows) = 3 mientras que grid[2].length es 4, lo que muestra que la longitud exterior cuenta las filas y cada fila tiene su propia longitud — sumadas dan total elements in grid = 9.

Práctica