Classe di utilità Java Arrays

java.util.Arrays è la raccolta di utility per array della libreria standard. È una classe final con soli metodi static — non la istanzi mai, chiami direttamente i suoi metodi: Arrays.sort(...), Arrays.toString(...), e così via. Una volta che sai cosa contiene, il codice per la gestione degli array che scrivi diventa molto più breve.

Questo capitolo è una guida guidata. Ordinamento e copia hanno capitoli propri; qui ci concentriamo sul resto.

Importazione

import java.util.Arrays;

Quasi tutti gli esempi seguenti presuppongono questa importazione.

toString e deepToString

Converte un array in una stringa leggibile. toString gestisce array monodimensionali:

int[] data = {3, 1, 4};
String s = Arrays.toString(data);   // "[3, 1, 4]"

deepToString formatta ricorsivamente gli array annidati:

int[][] grid = {{1, 2}, {3, 4}};
String s = Arrays.deepToString(grid);   // "[[1, 2], [3, 4]]"

Entrambi funzionano per tipi di elementi primitivi e oggetto.

equals e deepEquals

== confronta i riferimenti agli array. Per confrontare il contenuto:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
boolean same = Arrays.equals(a, b);   // true

Per array annidati usa deepEquals:

int[][] g1 = {{1, 2}, {3, 4}};
int[][] g2 = {{1, 2}, {3, 4}};
boolean same = Arrays.deepEquals(g1, g2);   // true

Entrambi considerano null == null come true.

hashCode e deepHashCode

Hash basati sul contenuto, utili quando una classe racchiude un array e necessita di equals/hashCode:

int[] data = {1, 2, 3};
int h = Arrays.hashCode(data);

Se sovrascrivi equals per usare Arrays.equals, devi sovrascrivere hashCode per usare Arrays.hashCode al fine di mantenere il contratto.

fill

Imposta ogni elemento a un valore, oppure imposta un intervallo:

int[] data = new int[5];
Arrays.fill(data, 7);              // {7, 7, 7, 7, 7}
Arrays.fill(data, 1, 4, 0);        // zero indexes 1..3

sort e parallelSort

Ordinamento in-place, crescente:

int[] data = {3, 1, 4, 1, 5};
Arrays.sort(data);                 // {1, 1, 3, 4, 5}

Per array molto grandi puoi usare parallelSort per distribuire il lavoro su più core. La trattazione completa dell'ordinamento — primitivi, oggetti, ordini personalizzati — si trova nel capitolo Ordinamento degli array.

binarySearch

Trova un elemento in un array ordinato in O(log n):

int[] sorted = {1, 3, 5, 7, 9};
int idx = Arrays.binarySearch(sorted, 5);   // 2
int miss = Arrays.binarySearch(sorted, 6);  // negative — encodes insertion point

Se l'elemento è assente, il valore restituito è -(insertionPoint) - 1. Quindi miss == -4 significa che 6 appartiene all'indice 3. Se l'input non è ordinato, il risultato è indefinito — ordina prima.

copyOf e copyOfRange

Restituisce un nuovo array, copiando i valori da uno esistente:

int[] data = {1, 2, 3, 4, 5};
int[] all   = Arrays.copyOf(data, data.length);    // exact copy
int[] grown = Arrays.copyOf(data, 8);              // padded with zeros
int[] slice = Arrays.copyOfRange(data, 1, 4);      // {2, 3, 4}

Questi sono trattati in dettaglio in Copia degli array.

asList

Racchiude un array di riferimenti come una List a dimensione fissa:

String[] arr = {"a", "b", "c"};
List<String> list = Arrays.asList(arr);

La lista è supportata dall'array — list.set(0, "z") modifica anche arr[0]. La dimensione è fissa, quindi add/remove lanciano eccezioni. Con array primitivi non fa quello che ci si aspetta: Arrays.asList(new int[]{1, 2, 3}) produce una List<int[]> di lunghezza uno. Per i primitivi, converti prima con gli stream.

stream

Ottieni uno stream da qualsiasi array numerico o di oggetti:

int[] nums = {3, 1, 4, 1, 5};
int sum = Arrays.stream(nums).sum();
double avg = Arrays.stream(nums).average().orElse(0);

Per array di oggetti, Arrays.stream(arr) restituisce un Stream<T>. Esistono anche forme con intervallo limitato — Arrays.stream(arr, from, to).

setAll e parallelSetAll

Riempie un array usando una funzione dell'indice:

int[] squares = new int[6];
Arrays.setAll(squares, i -> i * i);
// {0, 1, 4, 9, 16, 25}

Usa setAll quando vuoi una sequenza derivata e un ciclo for sarebbe solo rumore.

compare e mismatch (Java 9+)

Arrays.compare(a, b) restituisce un valore negativo, zero o positivo — ordine lessicografico sugli elementi:

int[] a = {1, 2, 3};
int[] b = {1, 2, 4};
int cmp = Arrays.compare(a, b);   // negative — a is smaller

Arrays.mismatch(a, b) restituisce l'indice del primo elemento diverso, o -1 se sono uguali:

int diff = Arrays.mismatch(a, b);   // 2

Quando un array è un prefisso proprio dell'altro, quello più corto è considerato "minore" da compare, e mismatch restituisce la lunghezza dell'array più corto:

int[] s = {1, 2};
int[] l = {1, 2, 3};
Arrays.compare(s, l);    // negative — s is a prefix, so it sorts first
Arrays.mismatch(s, l);   // 2 — they agree up to index 2, then s runs out

Questi sono utili quando hai bisogno di un ordine o di sapere "dove divergono" senza scrivere il ciclo a mano.

Errori comuni

Alcune trappole colgono le persone abbastanza spesso da valere la pena elencarle in un unico posto:

• == non è un confronto di contenuto. a == b è true solo quando entrambi i nomi puntano allo stesso oggetto array. Usa Arrays.equals (o Arrays.deepEquals per array annidati) per confrontare i contenuti.
• toString è superficiale. Arrays.toString(grid) su un int[][] stampa qualcosa come [[I@1b6d3586, ...] — gli array interni usano il loro Object.toString predefinito. Ricorri a Arrays.deepToString ogni volta che un array contiene altri array.
• asList con un array primitivo ti sorprende. Arrays.asList(new int[]{1, 2, 3}) è una List<int[]> di un elemento, non una List<Integer> di lunghezza tre, perché int[] è un singolo oggetto. Usa Arrays.stream(arr).boxed().toList() (Java 16+) per ottenere la lista che intendevi.
• asList ha dimensione fissa. È una vista sull'array originale, quindi set funziona ma add e remove lanciano UnsupportedOperationException. Racchiudilo in new ArrayList<>(Arrays.asList(...)) se hai bisogno di espanderlo.
• binarySearch richiede un array ordinato. Su input non ordinato il risultato è indefinito — non lancia eccezioni, restituisce semplicemente un indice errato. Ordina prima.

Un esempio pratico

La demo seguente mette insieme la maggior parte dei metodi. Eseguila e confronta l'output con i commenti precedenti — binarySearch restituisce 5 per il valore 5, il risultato negativo per un elemento assente, e la lista [red, green, blue] da asList:

Cosa c'è dopo

Abbiamo usato Arrays.sort solo di sfuggita. Il prossimo capitolo, Ordinamento degli array, approfondisce come funziona l'ordinamento per i primitivi rispetto agli oggetti, in ordine crescente rispetto a decrescente, e come ordinare secondo i propri criteri con un Comparator.

Esercitazione