Array di classe helper

1. Arraysclasse

Come abbiamo notato in precedenza, gli array sono molto utili e usati frequentemente nella programmazione.

I creatori di Java hanno notato molto rapidamente che i programmatori Java spesso scrivono lo stesso codice quando lavorano con gli array. Ad esempio, copia parte di un array in un altro array, codice per riempire ogni cella di un array con lo stesso valore, visualizza il contenuto di un array in un formato conveniente, ecc.

Ecco perché hanno creato la Arraysclasse speciale (il suo nome completo è java.util.Arrays), inserendovi le azioni più popolari relative agli array.

Ha molti metodi per ogni occasione, ma prima ne considereremo solo 10: i più semplici e quelli più usati.

2.Arrays.toString()

Il primo metodo che esamineremo si chiama Arrays.toString(). Ma prima, un po' di storia.

Ogni array in Java ha un toString()metodo, che restituisce una "rappresentazione testuale dell'array". È possibile ottenere una rappresentazione testuale di un array utilizzando la seguente istruzione:

String str = name.toString();

Dove nameè il nome della variabile matrice ed strè il nome della variabile che memorizzerà la rappresentazione di stringa della matrice.

Ma se provi a stampare l'array sullo schermo usando il metodo, molto probabilmente vedrai qualcosa del genere:System.out.println(name)

I@37afeb11

La prima lettera Iindica che si tratta di un intarray e i simboli successivi @sono l'indirizzo dell'array in memoria. Da un lato, questa è proprio l'informazione memorizzata nella variabile array, ma dall'altro ci aspettavamo qualcosa di diverso, giusto?

Volevamo vedere i valori nell'array! Ed è esattamente per questo che hanno ideato il Arrays.toString()metodo: visualizzare i valori di un array. Lo chiamiamo così:

String str = Arrays.toString(name);

Esempi:

int[] array = {1, 2, 3};
String str = Arrays.toString(array);

"[1, 2, 3]"

int[] array = {};
String str = Arrays.toString(array);

"[]"

String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);

"[Hi, How's, life?]"

3.Arrays.deepToString()

Ma se provi a convertire un array bidimensionale in un using the Arrays.toString()metodo stringa (per visualizzarlo), vedrai qualcosa di familiare:

[I@37afeb11, I@37afeb21, I@37afeb31]

Questo perché le celle di un array bidimensionale memorizzano riferimenti a array unidimensionali. E come vengono convertiti gli array unidimensionali in una stringa? Esattamente come vedi sopra.

Cosa si può fare? Come possiamo visualizzare correttamente un array bidimensionale?

A tal fine, la Arraysclasse ha un altro metodo speciale — deepToString(). Chiamandolo sembra così:

String str = Arrays.deepToString(name);

A questo metodo possono essere passati array bidimensionali, unidimensionali, tridimensionali o, in generale, qualsiasi dimensione e visualizzerà sempre gli elementi dell'array.
Nota: il Arrays.deepToString()metodo non funziona con array unidimensionali di primitive (ad esempio, int[]).

Esempi:

Integer[] array = {1, 2, 3};
String str = Arrays.deepToString(array);

"[1, 2, 3]"

int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);

"[[1, 1], [2, 2], [3, 3]]"

int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);

"[[[1, 2, 3], [1]], [[]]]"

4.Arrays.equals()

Abbiamo capito come visualizzare gli array sullo schermo, ma per quanto riguarda il confronto degli array?

Per confrontare le stringhe, abbiamo i metodi equalse equalsIgnoreCase, ma quali metodi hanno gli array?

La buona notizia è che gli array hanno un equalsmetodo. La cattiva notizia è che non confronta i contenuti degli array. Il equalsmetodo degli array fa la stessa cosa dell'operatore ==: confronta i riferimenti. Esempi:

Esempi:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
boolean b = x1 == x2;

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

Cosa si può fare? Come confrontiamo gli array in base al loro contenuto?

E ancora Arraysci viene in soccorso, o meglio, il suo Arrays.equals()metodo. Così lo chiamiamo:

Arrays.equals(name1, name2)

Il metodo restituisce truese gli array sono di uguale lunghezza e i loro elementi sono uguali. Altrimenti ritorna false.

Esempi:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);

5.Arrays.deepEquals()

E, come probabilmente hai già intuito, il Arrays.equalsmetodo non funzionerà correttamente per gli array bidimensionali: tratta gli array bidimensionali come un array unidimensionale i cui elementi sono indirizzi di array unidimensionali.

Pertanto, per confrontare correttamente gli array multidimensionali ( n = 1, 2, 3,...), hanno escogitato il Arrays.deepEquals()metodo. Chiamandolo sembra così:

Arrays.deepEquals(name1, name2)

Il metodo ritornatruese gli array sono di uguale lunghezza e i loro elementi sono uguali. Altrimenti ritornafalse. Se anche gli elementi all'interno dell'array sono array, il Arrays.deepEquals()metodo viene utilizzato per confrontarli e così via.

Esempi:

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
x1.equals(x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.equals(x1, x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.deepEquals(x1, x2);