Classe Arrays: sort, fill, copyOf, equals

1. Introduzione

Gli array in Java sono uno strumento potente, ma la sintassi di base presto si scontra con la routine. In aiuto arriva la classe java.util.Arrays — un insieme di metodi statici per lavorare con gli array: ordinamento, copia, confronto, stampa formattata e altro ancora. Non serve creare istanze — tutti i metodi sono statici e si invocano tramite il nome della classe.

Per usare i metodi, aggiungi l’import all’inizio del file:

import java.util.Arrays;

Se dimentichi l’import, il compilatore segnalerà che Arrays «non trovato» — non è un bug, ma il comportamento previsto senza import.

2. Ordinamento di un array: Arrays.sort

Come funziona Arrays.sort

Sintassi

Arrays.sort(massiv);
Arrays.sort(massiv, nachal’nyyIndeks, konechnyyIndeks);

Il metodo ordina «in place» — modifica l’array originale e non ne restituisce uno nuovo. Vuoi mantenere l’ordine originale? Copia prima l’array.

Esempio: ordinamento di un array di interi

int[] scores = {5, 2, 9, 1, 7};
Arrays.sort(scores); // Ordiniamo in ordine crescente

System.out.println("Array ordinato: " + Arrays.toString(scores));
// Stamperà: [1, 2, 5, 7, 9]

Esempio: ordinamento di un array di stringhe

String[] names = {"Vasya", "Petya", "Anya", "Igor’"};
Arrays.sort(names);

System.out.println(Arrays.toString(names));
// [Anya, Igor’, Petya, Vasya]

Importante: le stringhe vengono ordinate lessicograficamente (in ordine alfabetico), i numeri in ordine crescente.

Ordinare una parte dell’array

int[] arr = {7, 5, 3, 1, 9, 8};
Arrays.sort(arr, 1, 4); // ordina gli elementi dagli indici 1 a 3 inclusi (4 escluso)

System.out.println(Arrays.toString(arr));
// [7, 1, 3, 5, 9, 8]

Caratteristiche

• Ordinamento «in place»: l’array originale viene modificato.
• Numeri — in ordine crescente; stringhe — in ordine alfabetico.
• Per oggetti complessi usa le versioni sovraccariche con un Comparator.

3. Riempimento di un array: Arrays.fill

Sintassi

Arrays.fill(massiv, znachenie);
Arrays.fill(massiv, nachal’nyyIndeks, konechnyyIndeks, znachenie);

Il metodo riempie tutti gli elementi o la parte indicata dell’array con lo stesso valore.

int[] marks = new int[5];
Arrays.fill(marks, 3); // Tutti gli elementi ora valgono 3
System.out.println(Arrays.toString(marks)); // [3, 3, 3, 3, 3]

Riempimento di una parte dell’array

int[] arr = new int[10];
Arrays.fill(arr, 2, 5, 7); // Riempirà gli elementi dagli indici 2 a 4 inclusi (5 escluso)
System.out.println(Arrays.toString(arr));
// [0, 0, 7, 7, 7, 0, 0, 0, 0, 0]

Riempimento di un array di stringhe

String[] guests = new String[4];
Arrays.fill(guests, "Vuoto");
System.out.println(Arrays.toString(guests)); // [Vuoto, Vuoto, Vuoto, Vuoto]

4. Copia di un array: Arrays.copyOf e Arrays.copyOfRange

Arrays.copyOf

Sintassi

Arrays.copyOf(iskhodnyyMassiv, novayaDlina);

Crea un nuovo array e copia gli elementi da quello originale. Se la nuova lunghezza è maggiore di quella originale, la «coda» viene riempita con i valori predefiniti (0 per int, null per i riferimenti).

int[] original = {1, 2, 3};
int[] copy = Arrays.copyOf(original, 5);
System.out.println(Arrays.toString(copy)); // [1, 2, 3, 0, 0]

Riduzione dell’array

int[] shortCopy = Arrays.copyOf(original, 2);
System.out.println(Arrays.toString(shortCopy)); // [1, 2]

Arrays.copyOfRange

Sintassi

Arrays.copyOfRange(iskhodnyyMassiv, nachal’nyyIndeks, konechnyyIndeks);

int[] arr = {10, 20, 30, 40, 50};
int[] mid = Arrays.copyOfRange(arr, 1, 4); // Copierà gli elementi dagli indici 1 a 3
System.out.println(Arrays.toString(mid)); // [20, 30, 40]

5. Confronto di array: Arrays.equals e Arrays.deepEquals

In Java non si possono confrontare gli array con == — così si confrontano i riferimenti, non il contenuto:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b); // false!

Come confrontare il contenuto?

Arrays.equals(massiv1, massiv2);
Arrays.deepEquals(matritsa1, matritsa2);

System.out.println(Arrays.equals(a, b)); // true

Per gli array monodimensionali usa Arrays.equals, per quelli bidimensionali e più profondi — Arrays.deepEquals.

Esempio: confronto di array bidimensionali

int[][] matrix1 = {{1, 2}, {3, 4}};
int[][] matrix2 = {{1, 2}, {3, 4}};

System.out.println(Arrays.equals(matrix1, matrix2));     // false!
System.out.println(Arrays.deepEquals(matrix1, matrix2)); // true

6. Stampa leggibile di un array: Arrays.toString e Arrays.deepToString

La stampa diretta di un array produce una stringa illeggibile:

int[] arr = {1, 2, 3};
System.out.println(arr); // [I@7a81197d

Sintassi

Arrays.toString(massiv);
Arrays.deepToString(matritsa);

System.out.println(Arrays.toString(arr)); // [1, 2, 3]

int[][] matrix = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(matrix)); // [[1, 2], [3, 4]]

7. Errori tipici nell’uso della classe Arrays

Errore n. 1: tentare di confrontare array con ==
Gli array sono oggetti, e == confronta solo i riferimenti. Anche con gli stessi valori il risultato sarà false. Usa Arrays.equals (per i monodimensionali) o Arrays.deepEquals (per i multidimensionali).

Errore n. 2: dimenticare che l’ordinamento modifica l’array «in place»
Se serve l’ordine originale, crea prima una copia con Arrays.copyOf, poi ordina la copia. Altrimenti l’originale perderà il suo ordine.

Errore n. 3: interpretazione errata dei limiti in Arrays.fill e Arrays.copyOfRange
I metodi usano un intervallo semiaperto: l’indice destro è escluso. Per esempio, Arrays.fill(arr, 2, 5, 9) riempirà gli indici 2, 3, 4, mentre l’elemento con indice 5 non verrà toccato.

Errore n. 4: tentare di stampare un array direttamente
La chiamata System.out.println(arr) stampa una rappresentazione tecnica. Usa Arrays.toString per i monodimensionali e Arrays.deepToString per i multidimensionali.

Errore n. 5: confrontare array multidimensionali con Arrays.equals
Il metodo confronta solo il livello superiore (i riferimenti agli array interni). Per confrontare il contenuto usa Arrays.deepEquals.

1

Sondaggio/quiz

Array, livello 7, lezione 5

Non disponibile

Array

Introduzione agli array

Apri