Classe Array

Ciao di nuovo! :) Nella lezione di oggi parleremo della classe Arrays in Java. Nell'ultima lezione, abbiamo avuto modo di conoscere una tale struttura dati chiamata array. Abbiamo imparato come crearli e riempirli di dati. E abbiamo visto come sono immagazzinati nella memoria. Oggi esamineremo alcune attività ed esempi di utilizzo degli array che vedrai spesso nel lavoro reale. Ad esempio, immagina questa situazione: abbiamo una matrice di 10 numeri casuali.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Il nostro compito è ordinare questo array in ordine crescente: dal più piccolo al più grande. Alla fine, dovrebbe assomigliare a questo: [-234, -2, 16, 26, 35, 43, 92, 99, 167] Come lo facciamo? Questo compito non è banale. Non l'abbiamo mai fatto prima :/ Qualche idea? Provare ad indovinare. Ecco una soluzione:

• Esamina tutti gli elementi dell'array. Confronta ogni elemento con il successivo ([0] con [1], [1] con [2], [2] con [3], ecc.). Se l'elemento corrente è maggiore del successivo, li scambiamo e poi passiamo all'elemento successivo. In caso contrario, lasciali così come sono e vai avanti
• Pertanto, dopo il primo passaggio attraverso gli elementi, è garantito che il valore più grande (167) si trovi nell'ultima cella.
• Ora esamineremo di nuovo tutti gli elementi, ma questa volta inizieremo con l'indice [0] fino al penultimo elemento (il numero più grande è già al suo posto) e faremo gli stessi confronti e scambi. Dopo questo passaggio, nella penultima cella, avremo il secondo valore più grande (99).
• Ripeti questo processo tante volte quanti sono gli elementi dell'array.

Abbiamo l'idea. Ora dobbiamo solo scrivere il codice. Sembra così:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       for (int i = numbers.length - 1; i > 0; i--) {
           for (int j = 0; j < i; j++) {
           /* Compare the elements in pairs.
             If they are not in the right order,
             then swap them */
               if (numbers[j] > numbers[j + 1]) {
                   int tmp = numbers[j];
                   numbers[j] = numbers[j + 1];
                   numbers[j + 1] = tmp;
               }
           }
       }

   }
}

Uh... Sembra un po' complicato -_- Anche se il principio generale è comprensibile, dobbiamo ancora scrivere parecchio codice per risolvere un compito così semplice. Ok, forse ci siamo solo sopravvalutati? Il compito che abbiamo affrontato è probabilmente ancora troppo complicato per noi. Proviamo qualcosa di più semplice. Ad esempio, prendi lo stesso array di numeri.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

Il nostro compito è copiarne il contenuto in un altro array.

int [] numbersCopy = new int[10];

Pensa a come lo faresti usando ciò che già sai sugli array? Ad esempio, potresti passare attraverso l' array dei numeri in un ciclo e scrivere in sequenza i suoi elementi in numbersCopy :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = new int[10];

       for (int i = 0; i < numbers.length; i++) {

           numbersCopy[i] = numbers[i];
       }

   }
}

Bene, uh, qui l'abbiamo praticamente fatto! Sembra che abbiamo risolto il problema. Tuttavia, se devi farlo spesso, il tuo codice avrà una serie di loop identici. In effetti, questi (e altri) compiti sono stati risolti da tempo dai creatori di Java. Non abbiamo bisogno di "reinventare la ruota" e codificare la nostra soluzione. Esiste una classe statica speciale ( Array ) per aiutarti a eseguire attività comuni quando lavori con gli array. A questa classe sono stati aggiunti i metodi per eseguire le attività più comuni affrontate dai programmatori Java. Ad esempio, il compito di ordinare un array, che abbiamo cercato di gestire, è risolto in una sola riga:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       Arrays.sort(numbers);

       System.out.println(Arrays.toString(numbers));

   }
}

Il metodo Arrays.sort() ordina l'array. E il suo algoritmo è molto più efficiente del codice che abbiamo scritto. Output della console: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Nota: per convertire l'array in una stringa, abbiamo utilizzato un altro metodo della classe Arrays : Arrays.toString() . Gli array in Java non sovrascrivono il metodo toString() da soli. Quindi, se scrivi semplicemente

System.out.println(numbers.toString());

verrà chiamato toString() della classe Object . Per un array, l'output sarà simile a questo: [I@4554617c Non entreremo nei dettagli ora sul motivo per cui esattamente questo è l'output. La cosa principale è che chiaramente non è ciò di cui abbiamo bisogno. Ma Arrays.toString() fa esattamente quello che vogliamo. A proposito, anche la copia è facilmente realizzabile con la classe Arrays :

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Passiamo al metodo Arrays.copyOf() il nostro array originale (da cui vogliamo copiare i valori) e la lunghezza del nuovo array in cui stiamo copiando i dati. In questo caso, abbiamo indicato numbers.length come lunghezza, poiché vogliamo copiare l'intero array. Se volessimo copiare solo i primi elementi, possiamo specificare la lunghezza di un nuovo array più piccolo:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Qui abbiamo specificato 4 come lunghezza del nuovo array. Di conseguenza, solo i primi 4 elementi di numeri verranno copiati nel nuovo array. Output della console: [167, -2, 16, 99] A proposito, Arrays ti consente anche di copiare parte di un array dal centro anziché dall'inizio dell'array:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

       int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Output: [16, 99, 26, 92] I numeri sono stati copiati nel nuovo array dal secondo array dal secondo (incluso) al sesto elemento (non incluso). Potremmo anche dover confrontare due array. Come con il metodo toString() , gli array stessi non sovrascrivono il metodo equals() . Quindi, se proviamo a confrontarli in questo modo

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(numbers.equals(numbers2));
   }
}

allora otteniamo falso. Questo perché verrà chiamato Object.equals() , che confronta i riferimenti. E, ovviamente, sono diversi! Ma ciò di cui abbiamo bisogno è confrontare i contenuti dell'array, non i riferimenti. La classe Arrays sovrascrive il metodo equals() per fargli fare esattamente quello che vogliamo:

public class Main {

   public static void main(String[] args) {

       int[] numbers = {1, 2, 3};
       int[] numbers2 = {1, 2, 3};

       System.out.println(Arrays.equals(numbers, numbers2));
   }
}

Output: true A proposito, la classe Arrays funziona non solo con gli array ordinari, ma anche con quelli bidimensionali:

public class Main {

   public static void main(String[] args) {

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

       int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);

       System.out.println("Are these two-dimensional arrays equal?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));

       System.out.println(Arrays.deepToString(numbersCopy));
   }
}

Output: questi array bidimensionali sono uguali? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Come puoi vedere, il metodo Arrays.copyOf() è stato in grado di copiare un array bidimensionale. E la classe ha metodi speciali per confrontare e visualizzare array bidimensionali: deepEquals e deepToString() . In futuro, vedrai ripetutamente (e ti rallegrerai del fatto che) che i creatori di Java hanno anticipato molte situazioni frequentemente affrontate dai programmatori e hanno implementato soluzioni già pronte per loro nel linguaggio. Usare queste soluzioni è molto più semplice e conveniente che reinventare la ruota, giusto? :) Assicurati di leggere la documentazione per la classe Arrays sul sito web di Oracle . Buona fortuna per i tuoi studi.