Un array è una raccolta ordinata di dimensione fissa di elementi dello stesso tipo, memorizzati in modo contiguo in memoria. Gli array sono fondamentali, ma la loro dimensione fissa significa che spesso preferisci ArrayList per raccolte dinamiche.
[] nums = [];
[] nums2 = {, , , , };
String[] names = [];
nums[] = ;
nums[];
nums.length;
Gli array hanno una dimensione fissa impostata al momento della creazione — non puoi farli crescere o ridurre. Gli elementi hanno valori predefiniti appropriati al tipo (0, 0.0, false, null).
nums.length; // ✅ array — a field (no parentheses)
str.length(); // ✅ String — a method (parentheses)
list.size(); // ✅ collection — a method
L'length di un array è un campo; la length() di String e il size() di una raccolta sono metodi — un punto frequente di confusione.
int[] arr = {1, 2, 3};
arr[5]; // ❌ ArrayIndexOutOfBoundsException — Java checks bounds at runtime
Java genera un'eccezione per accesso fuori dai limiti (a differenza di C, che ha comportamento indefinito) — più sicuro, ma devi restare entro 0 e 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 semplice per dimensione fissa, dati sensibili alle prestazioni o primitivi; usa ArrayList quando la dimensione cambia o hai bisogno di operazioni convenienti.
Gli array sono una struttura dati fondamentale in Java — archiviazione veloce, efficiente in memoria e contigua utilizzata direttamente e come base per molte raccolte (ArrayList racchiude un array).
Comprendere la loro natura a dimensione fissa, l'indicizzazione basata su 0, la verifica dei limiti a runtime, la trappola del campo length (vs metodo), e soprattutto quando usare un array vs ArrayList (fisso/primitivo/veloce vs dinamico/conveniente) è essenziale.
Gli array appaiono costantemente in algoritmi e codice critico per le prestazioni, mentre conoscere i loro limiti (nessun ridimensionamento) spiega perché esistono raccolte dinamiche e sono di solito preferite per l'uso generale.