Un array es una colección ordenada de tamaño fijo de elementos del mismo tipo, almacenados contiguamente en memoria. Los arrays son fundamentales, pero su tamaño fijo significa que a menudo prefieres ArrayList para colecciones dinámicas.
[] nums = [];
[] nums2 = {, , , , };
String[] names = [];
nums[] = ;
nums[];
nums.length;
Los arrays tienen un tamaño fijo establecido en la creación — no puedes hacerlos crecer ni encogerse. Los elementos toman valores predeterminados apropiados para el tipo (0, 0.0, false, null).
nums.length; // ✅ array — a field (no parentheses)
str.length(); // ✅ String — a method (parentheses)
list.size(); // ✅ collection — a method
El length de un array es un campo; length() de String y size() de colecciones son métodos — un punto frecuente de confusión.
int[] arr = {1, 2, 3};
arr[5]; // ❌ ArrayIndexOutOfBoundsException — Java checks bounds at runtime
Java lanza una excepción para el acceso fuera de los límites (a diferencia de C, que tiene un comportamiento indefinido) — más seguro, pero debes permanecer dentro de 0 a length-1.
// enhanced for-each (when you don't need the index)
for (int n : nums) {
System.out.println(n);
}
// traditional for (when you need the index)
for (int i = 0; i < nums.length; i++) {
nums[i] *= 2;
}
int[][] matrix = {{1, 2}, {3, 4}}; // array of arrays
matrix[0][1]; // 2
Array → fixed size, slightly faster, can hold primitives directly (int[])
ArrayList → DYNAMIC size (grow/shrink), rich methods (add/remove/contains),
but holds objects only (Integer, not int)
List<Integer> list = new ArrayList<>();
list.add(1); // grows dynamically — no fixed size
list.remove(0);
Usa un array simple para tamaño fijo, código sensible al rendimiento, o datos primitivos; usa ArrayList cuando el tamaño cambia o necesitas operaciones convenientes.
Los arrays son una estructura de datos fundamental en Java — rápidos, eficientes en memoria, almacenamiento contiguo usado directamente y como base para muchas colecciones (ArrayList envuelve un array).
Entender su naturaleza de tamaño fijo, indexación basada en 0, comprobación de límites en tiempo de ejecución, la trampa del campo length (versus método) y especialmente cuándo usar un array versus ArrayList (fijo/primitivo/rápido versus dinámico/conveniente) es esencial.
Los arrays aparecen constantemente en algoritmos y código crítico para el rendimiento, mientras que comprender sus limitaciones (sin redimensionamiento) explica por qué existen colecciones dinámicas y generalmente se prefieren para uso general.