Array — una classe helper

"Amigo, spero che ormai ti sia reso conto di quanto siano utili gli array nella programmazione?"

"Sicuramente, Rishi! Ho già risolto più di un compito."

"I tuoi compiti avevano azioni ripetitive? Il tipo che hai fatto più e più volte."

"Se ho capito bene, intendi azioni simili in compiti diversi? Ad esempio, ovunque usando un ciclo per visualizzare il contenuto di un array - sono così stanco di farlo!"

"Sì, è quello che intendo. I creatori di Java hanno notato che i programmatori Java spesso scrivono lo stesso codice quando lavorano con gli array. Ad esempio, codice per copiare parte di un array in un altro array o codice per riempire ogni cella di un array con lo stesso value.O il tuo esempio: codice per visualizzare il contenuto di un array in una forma leggibile sullo schermo.

"E i veri programmatori hanno una regola molto importante: non ripeterti. Converrai che è sbagliato fare un lavoro superfluo, non verrai pagato per questo. Un lavoro efficace è ben pagato, credimi. Per inciso, un principiante codice è immediatamente riconoscibile dalla grande quantità di codice ripetitivo.

"I creatori di Java hanno riflettuto su questo e hanno creato la Arraysclasse speciale (il suo nome completo è java.util.Arrays), inserendovi le azioni più popolari relative agli array."

"Hmm... Molto interessante. Quindi cosa contiene esattamente?

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

Arrays.toString()

"Il primo metodo che esamineremo è Arrays.toString()... Ma prima, un po' di retroscena.

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

String str = name.toString();

"Dov'è nameil nome della variabile array, ed strè il nome della variabile che memorizzerà la rappresentazione di stringa dell'array. Amigo, hai provato a stampare un array sullo schermo usando il metodo?System.out.println(name)

Lo confesso, è successo. Ho visto delle chiacchiere. Ho deciso di stare lontano dai pericoli e di continuare a usare i loop.

"Molto probabilmente hai visto qualcosa del tipo:

I@37afeb11

"La prima lettera Isignifica che è un intarray, e i simboli che seguono @sono l'indirizzo di un singolo oggetto in memoria. Puoi pensarlo come l'indirizzo dell'array in memoria. Da un lato, questa è precisamente l'informazione memorizzata nel variabile array, ma dall'altra ti aspettavi qualcosa di diverso, vero?"

"Esattamente! Avevo intenzione di vedere i valori nell'array. Questa era l'ultima cosa che mi aspettavo."

"E questo è esattamente il motivo per cui 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);

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

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

Arrays.deepToString()

"Tuttavia, il toString()metodo non è adeguato quando si tratta di array bidimensionali. In altre parole, se provi a chiamare Arrays.toString(), vedrai qualcosa di familiare:

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

"Questo è tutto 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 fare allora? Come possiamo visualizzare correttamente un array bidimensionale?"

"Anche i creatori di Java hanno anticipato questo. A tal fine, la Arraysclasse ha un altro metodo speciale — deepToString(). Chiamarlo assomiglia a questo:

String str = Arrays.deepToString(name);

"Questo metodo può essere passato ad array bidimensionali, unidimensionali, tridimensionali o, in generale, di qualsiasi dimensione, e visualizzerà sempre gli elementi dell'array.

Esempi:

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

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

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

Arrays.equals()

"Abbiamo capito come visualizzare gli array sullo schermo. Che ne dici di confrontare gli array? Ricordi quali metodi possiamo usare per confrontare le stringhe?"

"Di solito uso il equalsmetodo!

"Sì, equalse anche equalsIgnoreCase(che confronta le stringhe indipendentemente da maiuscole e minuscole).

"Buone notizie: puoi anche usare il equalsmetodo per gli array. Cattive notizie: non confronta i contenuti degli array. Il equalsmetodo degli array fa la stessa cosa dell'operatore ==: confronta i riferimenti.

Esempi:

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

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

"Allora cosa facciamo? Come confrontiamo gli array in base al loro contenuto?"

"Ancora una volta la Arraysclasse viene in nostro soccorso. Più specificamente, il suo Arrays.equals()metodo. Così lo chiamiamo:

Arrays.equals(name1, name2)

"Il metodo restituisce truese gli array sono di uguale lunghezza e i relativi elementi sono uguali. In caso contrario, restituisce 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);

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.

"Così, per confrontare correttamente gli array multidimensionali ( n = 1, 2, 3,... ), hanno escogitato il Arrays.deepEquals()metodo. Chiamarlo assomiglia a questo:

Arrays.deepEquals(name1, name2)

"Il metodo restituisce truese gli array sono di uguale lunghezza e i relativi elementi sono uguali. In caso contrario, restituiscefalse. 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);

"Grazie, Rishi! Questa lezione è proprio ciò di cui avevo bisogno per rendere la mia vita più facile e più felice in futuro. Ora userò i metodi della classe Arrays e scriverò i miei programmi ancora più velocemente.

"È quello su cui contavo, ha-ha. Ma questi non sono tutti i metodi interessanti della classe Arrays. Te ne parlerò degli altri la prossima volta."