1.Arrays.fill()

Quando si lavora con gli array, i programmatori Java molto spesso devono riempire l'array con lo stesso valore. Ovviamente puoi scrivere un ciclo e assegnare semplicemente 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;

Oppure puoi semplicemente 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);

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 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);

Stiamo riempiendo le celle x[3], x[4], x[5]e x[6]con il valore 999. Le celle di un array sono numerate a partire da zero!

La strvariabile contiene il valore:
"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

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

2.Arrays.copyOf()

Come già sai, non puoi ridimensionare un array dopo che è stato creato.

Ma cosa succede se lo vuoi davvero?

Java university

Bene, se lo vuoi davvero, allora puoi!

  • Crea un nuovo array della lunghezza desiderata
  • Copia tutti gli elementi dal primo array in esso.

A proposito, questo è esattamente ciò 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.

Se gli elementi non si adattano (la lunghezza è inferiore alla lunghezza dell'array esistente ), i valori extra vengono ignorati.

Se la lunghezza della nuova matrice è maggiore della lunghezza di quella vecchia, 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);

La str2variabile contiene il valore:
"[1, 2, 3, 4, 5]"

La str3variabile contiene il valore:
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.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?

ArraysIn questo caso, tornerà utile un altro metodo della classe: il file Arrays.copyOfRange(). Ecco come appare quando lo chiamiamo:

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 devono essere inseriti nel nuovo array.

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

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);

La str2variabile contiene il valore:
"[16, 17, 18, 19, 20]"

La str3variabile contiene il valore:
"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

Ah, la sorpresa più deliziosa: lo smistamento . Gli array vengono ordinati abbastanza spesso nella programmazione. Le tre azioni più comuni quando si lavora con gli array sono:

  • 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)

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


La strvariabile contiene il valore:
"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Eccellente, vero? Hai chiamato un metodo e ora hai un array ordinato. Bellissimo.

A proposito, puoi usare questo metodo per ordinare non solo l'intero array, ma 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 deve toccare.

In accordo con la buona 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);

La strvariabile contiene il valore:
"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

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

L'ordinamento di un array di 1000 elementi comporterà circa 3000 confronti di elementi dell'array. L'ordinamento di un array di un milione di elementi comporterà circa 6 milioni di confronti.

5.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 buttiamo fuori un'altra metà e così via.

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

Ecco come appare chiamarlo:

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

Dove nameè il 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);
 xÈ:
{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

4
1(indici 0e 2sono anche accettabili)
8
-7

Se l'array contiene più istanze dell'elemento cercato, allora l'algoritmo restituirà semplicemente l'indice di uno di essi (non c'è alcuna garanzia che sarà, diciamo, il primo, o viceversa — l'ultimo di questi elementi duplicati)."

Se l'elemento non viene trovato nell'array, l'indice sarà negativo.

6. Collegamento alla documentazione Oracle sulla Arraysclasse

Se sei super interessato, puoi leggere tutto sulla Arraysclasse e tutti i suoi metodi nella documentazione ufficiale a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">sul sito Web di Oracle.

Ad esempio, puoi leggere i metodi Arrays.mismatch()e Arrays.compare(). Forse li troverai utili in qualche modo.

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