Lezione sugli array, parte 2

"Rishi, non vedo davvero l'ora di conoscere il resto dei metodi della classe Arrays.

"Tale zelo per l'apprendimento non può che piacere al tuo vecchio maestro! Ma, se vuoi davvero scoprire tutto, un mago gentile di nome Google ti aiuterà giorno e notte."

"Ehm..."

"Sto solo scherzando. Più o meno. Certo, spiegherò tutto meglio, ma se succede qualcosa, ricordati del buon mago. Inizierò la lezione di oggi con il Arrays.fillmetodo

"Quando lavorano con gli array, i programmatori Java molto spesso devono riempire l'array con lo stesso valore. Puoi, ovviamente, scrivere un ciclo e semplicemente assegnare un valore a ciascuna cella dell'array nel ciclo:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

"O invece di tutto questo, puoi chiamare il Arrays.fill()metodo, che fa esattamente la stessa cosa: riempie l'array passato con il valore passato. Ecco come appare:

Arrays.fill(name, value)

E il codice nell'esempio sopra può essere reso un po' più compatto e chiaro:

int[] x = new int[100];
Arrays.fill(x, 999);

"Bellissimo!"

"Puoi anche usare il Arrays.fill()metodo per riempire non l'intero array, ma una parte di esso, con un valore:

Arrays.fill(name, first, last, value)

"Dove first e last sono gli indici della prima e dell'ultima cella da riempire.

" In accordo con la buona (o cattiva) vecchia tradizione di Java, ricorda che l'ultimo elemento non è incluso nell'intervallo.

Esempio:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

"Il Arrays.fill()metodo funziona solo con array unidimensionali. Se passi un array bidimensionale al metodo, verrà trattato come unidimensionale, con tutte le conseguenze che ne derivano.

Arrays.copyOf()

"Amigo, per favore dimmi come cambiare la dimensione di un array dopo che è stato creato?"

"Umm... Questa è una domanda trabocchetto, giusto? Non sono più così inesperto. La risposta corretta è che non puoi! Non puoi ridimensionare un array dopo che è stato creato."

"Ma se lo volessi davvero?"

"È ancora impossibile!

"In realtà, se vuoi davvero, allora puoi! Con l'aiuto di un trucco di programmazione:

1. Innanzitutto, crei un nuovo array della lunghezza desiderata
2. Quindi copi tutti gli elementi dal primo array in esso.

"Queste sono le due cose che Arrays.copyOf()fa il metodo. Ecco come appare chiamarlo:

Type[] name2 = Arrays.copyOf(name, length);

"Questo metodo non modifica l'array esistente , ma crea invece un nuovo array e vi copia gli elementi del vecchio array."

"Cosa succede se la lunghezza del nuovo array è inferiore alla lunghezza di quello esistente ?

"Ottima domanda, Amigo! Se gli elementi non combaciano, i valori extra vengono semplicemente ignorati."

"E se, al contrario, ci sono celle in più, quali sono i loro valori iniziali?

"Se la lunghezza del nuovo array è maggiore della lunghezza di quello vecchio, le celle vengono riempite con zeri.

Esempio:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Arrays.copyOfRange()

"E se si desidera ottenere un array di lunghezza 5 da un array di lunghezza 10, ma è necessario che contenga gli ultimi 5 elementi anziché i primi 5? In questo caso, è necessario un altro metodo della classe. ArraysÈ Arrays.copyOfRange()Ecco come si presenta la chiamata:

Type[] name2 = Arrays.copyOfRange(name, first, last);

"Questo metodo crea anche un nuovo array, ma lo riempie con elementi da una posizione arbitraria nell'array originale. Dove first e last sono gli indici del primo e dell'ultimo elemento che dovrebbero essere inseriti nel nuovo array. Puoi dirmi se l'ultimo elemento è compreso in questo intervallo?"

"Ah! Come diceva il mio grande maestro, ' secondo la buona (o cattiva) vecchia tradizione di Java, ricorda che l'ultimo elemento non è incluso nell'intervallo '."

"Amigo, stai crescendo sotto i nostri occhi.

Esempio:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Arrays.sort()

"E infine, ho lasciato per ultimo il metodo più... mmm... piacevole: sorting . Gli array vengono ordinati abbastanza spesso nella programmazione. Ecco le 3 azioni più popolari quando si lavora con gli array:

• Ordinamento di un array
• Trovare l'elemento minimo (o massimo) di un array
• Determinare l'indice di un elemento in un array (trovare un elemento in un array)

"Algoritmi di ordinamento ben eseguiti, devo dire, non sono così facili da scrivere. Più precisamente, questo è un compito standard e, come studente, non ti farà male esercitarti a scrivere algoritmi di ordinamento a volte. Ma al lavoro, è meglio non perdere tempo a reinventare la ruota.I creatori di Java hanno incluso il sort()metodo nella Arraysclasse.Ecco come appare chiamarlo:

Arrays.sort(name);

Questo metodo ordina l'array passato in ordine crescente.

Esempio:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);
String str = Arrays.toString(x);

"Eccellente! Ho chiamato solo un metodo e l'array è stato ordinato. Una bellezza!"

"A proposito, puoi ordinare non solo l'intero array, ma anche solo una parte di esso. Ecco come appare chiamarlo:

Arrays.sort(name, first, last);

"Dove first e last sono gli indici della prima e dell'ultima cella che l'ordinamento dovrebbe toccare. E...

"So già cosa dirai! 'Secondo la buona (o cattiva) vecchia tradizione di Java, ricorda che l'ultimo elemento non è incluso nell'intervallo' .

Esempio:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"Per ordinare gli array, Java utilizza l'algoritmo di ordinamento più veloce: QuickSort . La sua complessità computazionale dipende dalla dimensione dell'array e viene calcolata utilizzando la formula N log(N).

"L'ordinamento di un array di 1000 elementi comporterà circa 10.000 confronti di elementi dell'array. L'ordinamento di un array di un milione di elementi comporterà circa 20 milioni di confronti".

" Non troppi confronti se si considera il numero di elementi!"

"Questo è esattamente quello che sto dicendo. L' algoritmo QuickSort è molto efficiente.

Arrays.binarySearch()

"Bene, e l'ultimo dei metodi più interessanti della Arraysclasse è in grado di cercare un dato valore in un array. Questa non è una ricerca ordinaria: è l'amata ricerca binaria . Si riduce a questo:

• Innanzitutto, l'array viene ordinato.
• Quindi l'elemento centrale dell'array viene confrontato con quello che stiamo cercando.
• Se l'elemento è maggiore dell'elemento centrale, la ricerca continua nella metà destra dell'array.
• Se l'elemento che stiamo cercando è minore dell'elemento centrale, la ricerca continua nella metà sinistra dell'array.

"Poiché l'array è ordinato, è possibile eliminarne metà in un unico confronto. Quindi, nel passaggio successivo, ne eliminiamo un'altra metà e così via."

"Fantastico! Andiamo dritti all'obiettivo molto velocemente!"

"Esattamente. In un array di un milione (!) di elementi, l'algoritmo di ricerca binaria può trovare l'indice dell'elemento desiderato in soli 20 confronti. Il difetto dell'algoritmo è che l'array deve essere prima ordinato e anche l'ordinamento richiede tempo.

Ecco come appare chiamarlo:

int index = Arrays.binarySearch(name, value);

"Dov'è nameil nome dell'array, che deve essere passato già ordinato (ad esempio, utilizzando il Arrays.sort()metodo). Ed valueè l'elemento che stiamo cercando nell'array. Il risultato restituito dal metodo è l' indice dell'elemento dell'array desiderato .

Esempi:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

"Cosa succede se l'elemento desiderato appare più volte nell'array ?"

"Questa è una domanda valida, Amigo. In questo caso, l'algoritmo restituirà l'indice di uno di essi (non c'è alcuna garanzia che sarà, diciamo, il primo, o viceversa — l'ultimo di questi elementi duplicati) ."

"Cosa succede se l'array non contiene affatto l'elemento desiderato?"

"In questo caso, l'algoritmo restituirà un indice negativo .

Documentazione

"È tutto chiaro, Rishi! Questo è stato molto interessante."

"Se l'hai trovato davvero molto interessante, sfoglia a tuo piacimento la documentazione ufficiale della Arraysclasse e dei suoi metodi sul sito web di Oracle .

"Puoi dare un'occhiata più da vicino, ad esempio, ai metodi Arrays.mismatch()e Arrays.compare(). Molto probabilmente sarai in grado di farne buon uso.

"E non lasciarti confondere dal numero di metodi. Ogni metodo ha 5-10 varianti, che differiscono solo per i tipi di parametri."