Classe Array e suo utilizzo

Ciao di nuovo! :) Nell'ultima lezione, abbiamo conosciuto una struttura dati come un array (array Java), abbiamo imparato come creare array, riempirli di dati e anche come vengono archiviati in memoria. Oggi esamineremo alcune attività ed esempi di utilizzo degli array che incontrerai spesso nel lavoro reale. Ad esempio, immagina questa situazione: abbiamo una matrice di 10 numeri scritti in ordine casuale.

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

Il nostro compito è ordinare questo array in ordine crescente: dai numeri più piccoli a quelli più grandi. Alla fine dovrebbe assomigliare a questo:

[-234, -2, 16, 26, 35, 43, 80, 92, 99, 167]

Come facciamo questo? Il compito non è banale, non l'abbiamo mai fatto prima:/ Qualche idea? Provare ad indovinare. Ecco cosa possiamo fare, ad esempio:

• Scorrere 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 dell'array è più grande di quello successivo, li scambiamo e passiamo all'elemento successivo. In caso contrario, lascialo così com'è e vai avanti.


• Pertanto, dopo il primo passaggio attraverso gli elementi dell'array, è garantito che il valore più grande (167) si trovi nell'ultima cella.


• Ora esaminiamo nuovamente tutti gli elementi dell'array, iniziando dall'elemento con indice [0], ma fino al penultimo elemento (il numero più grande è già al suo posto) e facciamo gli stessi confronti e scambi. 
  Alla fine, nella penultima cella avremo il secondo valore più alto (99).


• Ripetiamo questo lavoro tante volte quanti sono gli elementi meno uno nell'array.

L'idea ci è venuta, non resta che scrivere il codice. Apparirà 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 in the wrong 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 di funzionamento è chiaro, devi scrivere parecchio codice per risolvere un compito apparentemente semplice. Ok, forse ci siamo semplicemente sopravvalutati? Probabilmente il compito che ci siamo assunti finora è troppo difficile per noi. Proviamo a fare qualcosa di più semplice. Ad esempio, prendiamo la stessa matrice di numeri.

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

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

int [] numbersCopy = new int[10];

Pensa a come lo faresti utilizzando la conoscenza degli array che già possiedi? Puoi, ad esempio, scorrere un array numberse scrivere i suoi elementi uno per uno 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, più o meno ce l'abbiamo fatta! Il problema sembra essere stato risolto, ma ancora una volta: se deve essere eseguito spesso, il codice avrà una serie di cicli identici. In effetti, questi e altri problemi sono stati risolti da tempo dai creatori di Java, e non abbiamo bisogno di “reinventare la ruota” e scrivere del codice per la nostra soluzione.

Classe Array Java

Una speciale classe Java ti aiuterà a risolvere i problemi tipici quando lavori con gli array - Arrays. A questa classe sono stati aggiunti metodi per risolvere i problemi più comuni che i programmatori Java incontrano nel loro lavoro. Ad esempio, il compito di ordinare un array, per il quale noi stessi abbiamo cercato di trovare soluzioni, può essere risolto in una 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. Inoltre, l'algoritmo incorporato al suo interno lo rende molto più efficiente del codice che abbiamo scritto. Uscita console:

[-234, -2, 16, 26, 35, 43, 80, 92, 99, 167]

Nota: per convertire l'array in una stringa, abbiamo utilizzato un altro metodo di classe Arrays- Arrays.toString(). Gli stessi array Java non sovrascrivono i file toString(). Quindi se scrivi e basta

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

verrà chiamato il metodo toString()della classe Object. Nel caso degli array, l'output sarà qualcosa del genere:

[I@4554617c

Ora non entreremo nei dettagli sul perché la conclusione è questa; la cosa principale è che questo chiaramente non è ciò di cui abbiamo bisogno. Ma Arrays.toString() ha fatto quello che volevamo. A proposito, anche il nostro problema con la copia è facilmente risolvibile in 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));

   }
}

Al metodo Arrays.copyOf()passiamo il nostro array originale (da cui dobbiamo copiare i valori) e la lunghezza del nuovo array in cui copiamo i dati. In questo caso, abbiamo indicato come lunghezza numbers.length, perché vogliamo copiare l'intero array. Se vogliamo copiare solo i primi elementi, possiamo specificare una lunghezza minore per il nuovo 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.copyOf(numbers, 4);
       System.out.println(Arrays.toString(numbersCopy));

   }
}

Qui abbiamo specificato che la lunghezza del nuovo array è 4. Di conseguenza, solo i primi 4 elementi numbersverranno copiati nel nuovo array. Uscita console:

[167, -2, 16, 99]

A proposito, se devi copiare parte di un array, ma non dall'inizio, ma "dal centro", Arrayspuoi farlo anche questo:

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

   }
}

Conclusione:

[16, 99, 26, 92]

I numeri dalle celle da due ( incluso ) a sei ( non compreso ) sono stati copiati nel nuovo array. Inoltre, potrebbe essere necessario confrontare due array tra loro. Proprio 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));
   }
}

otteniamo il risultato false. Object.equals()Dopotutto, il metodo che confronta i collegamenti si chiamerà . E ovviamente sono diversi! Ma dobbiamo confrontare il contenuto degli array, non i collegamenti. La classe Arrayscontiene un metodo sovrascritto equals()che fa esattamente ciò di cui abbiamo bisogno:

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

Conclusione:

true

A proposito, la classe Arraysfunziona con successo 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 to each other?");
       System.out.println(Arrays.deepEquals(numbers, numbersCopy));

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

Conclusione:

Равны ли эти двумерные массивы между собой?
true
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Come puoi vedere, il metodo Arrays.copyOf()ha gestito la copia di un array bidimensionale. Tieni presente che in questo caso, quando si copia un array bidimensionale, si verifica la cosiddetta "copia superficiale". E per confrontare array bidimensionali e inviarli alla console, vengono forniti metodi speciali - deepEqualse deepToString(); In futuro, vedrai più di una volta (e ne sarai felice) che i creatori di Java hanno previsto molte situazioni tipiche che i programmatori incontrano durante il lavoro e hanno implementato soluzioni già pronte per loro nel linguaggio. Usare queste soluzioni è molto più semplice e conveniente che reinventare le ruote, giusto? :) Assicurati di leggere la documentazione della classe Arrayssul sito web di Oracle . Buona fortuna con i tuoi studi!