Collezioni in Java | Collezioni Java

Ciao! Nelle ultime lezioni abbiamo fatto grandi progressi nella padronanza di ArrayList. Tuttavia, durante questo periodo abbiamo eseguito solo le operazioni più semplici: eliminazione, inserimento, output sulla console. Naturalmente, questa non è la fine dell'elenco dei problemi che gli sviluppatori devono affrontare quando utilizzano ArrayList . Ricordi la lezione sugli array e sulla classe Arrays ? È stato sviluppato dai creatori di Java appositamente per risolvere i problemi comuni che i programmatori incontrano quando lavorano con gli array. E che dire di ArrayList ? Sicuramente c'è anche un elenco di compiti tipici per lui. Sono stati tutti implementati in una classe separata o dovremo scrivere manualmente il comportamento desiderato ogni volta? Naturalmente non è necessario scrivere tutto da soli. Le operazioni più comuni eseguite quando si utilizzano le raccolte in Java sono già state implementate in una speciale classe statica Collections.

Collezioni in Giava

"Raccolte" è un nome generico per diverse strutture dati in Java. I dati possono essere archiviati in molti modi diversi. Finora abbiamo studiato solo la classe ArrayList , dove i dati sono memorizzati in un array. Più tardi conosceremo il resto delle collezioni. Ora basta capire che la classe Collections è progettata per funzionare non solo con ArrayList, ma anche con altri tipi di raccolte in Java (da cui, appunto, il suo nome). Quindi, quali attività la classe Collections ti consente di risolvere quando lavori con ArrayList? Il primo e più ovvio è l'ordinamento. Nella lezione sugli array abbiamo visto un esempio con i numeri, ora vediamo un esempio con le stringhe. Per ordinare il contenuto delle raccolte, la classe Collections implementa il seguente metodo sort():

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       System.out.println(solarSystem);

   }
}

Conclusione:

[Венера, Земля, Марс, Меркурий, Нептун, Сатурн, Уран, Юпитер]

Le linee sono state ordinate alfabeticamente! Perché in ordine alfabetico? La classe Stringè programmata per determinare esattamente come le stringhe vengono confrontate tra loro (precisamente in ordine alfabetico). Per le classi che creerai tu stesso, puoi implementare il tuo meccanismo di confronto, ma ne parleremo in altre lezioni. Inoltre, la classe Collections ti consente di trovare l'elemento minimo e massimo in un file ArrayList. Questo viene fatto utilizzando i metodi min()e max():

public static void main(java.lang.String[] args) {

   ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7));
   System.out.println(Collections.max(numbers));
   System.out.println(Collections.min(numbers));

}

Conclusione:

7
1

Questo, ovviamente, è molto più conveniente che scrivere manualmente il codice per esaminare tutti gli elementi e cercare l'elemento più grande/più piccolo :) Un altro metodo estremamente utile è reverse(). Se avessimo bisogno di “invertire” un elenco in modo che gli elementi fossero in ordine inverso, come lo faremmo? Probabilmente non sarebbe così facile scrivere da soli un algoritmo del genere :) Fortunatamente, il metodo reverse()sa già come farlo. Ad esempio, non ci piace il modo in cui il metodo sort()ha ordinato i nostri pianeti in ordine alfabetico e vogliamo cambiare l'ordine al contrario, dalla Z alla A:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       Collections.reverse(solarSystem);
       System.out.println(solarSystem);

   }
}

Conclusione:

[Юпитер, Уран, Сатурн, Нептун, Меркурий, Марс, Земля, Венера]

A proposito, qui parliamo spesso di ordinamento, ordine degli elementi, ecc. E se il nostro compito fosse esattamente l’opposto? Ad esempio, stiamo cercando di implementare un meccanismo di lotteria. Abbiamo aggiunto 100 numeri alla bobina, che dovrebbero apparire sullo schermo uno alla volta. Vince il primo partecipante che cancella tutti i numeri sul proprio biglietto. È molto semplice implementare un tale meccanismo utilizzando il metodo shuffle():

public class Main {

   public static void main(java.lang.String[] args) {

       ArrayList<Integer> lottery = new ArrayList<>(100);
       for (int i = 1; i <= 100; i++) {

           lottery.add(i);//add numbers from 1 to 100 to the drum
       }

       Collections.shuffle(lottery);//mix
       System.out.println("Attention! The first 10 numbers appear from the drum!");
       for (int i = 0; i < 10; i++) {

           System.out.println(lottery.get(i));
       }

   }
}

Conclusione:

Внимание! Из барабана появляются первые 10 чисел!
32
61
4
81
25
8
66
35
42
71

È così semplice! Il problema è risolto e la nostra parte del gioco è scritta :) Ora immaginiamo una situazione diversa. In precedenza, abbiamo creato un elenco solarSystemcon i pianeti elencati al suo interno. E sembra adatto a tutti, se non per una cosa: puoi rimuovere elementi da esso e aggiungerne di nuovi! Questo chiaramente non è il comportamento che ci aspettiamo: il sistema solare nel nostro programma dovrebbe essere in uno stato invariato. La classe Collections ha un metodo molto interessante: unmodifiableList(). Crea una versione immutabile dell'elenco fornito. Sarà impossibile aggiungere o rimuovere un elemento ad esso. Nel caso dell'elenco dei pianeti del sistema solare, questo è esattamente ciò di cui abbiamo bisogno!

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       List<String> solarSystem = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune)));
       solarSystem.add("Pluto");//try to add a new element
   }
}

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.Collections$UnmodifiableCollection.add(Collections.java:1075)
	at Main.main(Main.java:21)

Errore: solarSystemora non puoi aggiungere nulla! L'unica cosa a cui devi prestare attenzione in questo caso è che il tipo della variabile deve essere List<>, e non ArrayList<>(questo metodo restituisce un oggetto esattamente di questo tipo, comune a tutti i tipi di liste). Un'altra situazione comune che può verificarsi durante il lavoro è che il programmatore abbia aggiunto elementi nell'ordine sbagliato. Se ciò accadesse e Mercurio e Nettuno cambiassero posto inaspettatamente, il seguente metodo ci aiuterà a correggere questo errore swap():

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(neptune, venus, earth, mars
       , jupiter, saturn, uranus, mercury));// wrong planet order
       System.out.println(solarSystem);

       Collections.swap(solarSystem, solarSystem.indexOf(mercury), solarSystem.indexOf(neptune));
       System.out.println(solarSystem);

   }
}

Abbiamo passato la nostra lista al metodo swap(), così come gli indici dei due elementi che devono essere scambiati. Nota: il metodo funziona specificamente con gli indici e non con i collegamenti. Pertanto, qui avevamo bisogno di un metodo ArrayList.indexOf(). Conclusione:

[Нептун, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Меркурий]

[Меркурий, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Нептун]

Infine, facciamo conoscenza con un metodo molto interessante: disjoint(). Controlla se due raccolte hanno intersezioni, cioè almeno un elemento identico. In caso contrario, restituisce true, se sì, restituisce false.

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystemPart1 = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars));
       ArrayList<String> solarSystemPart2 = new ArrayList<>(Arrays.asList(jupiter, saturn, uranus, neptune));

       System.out.println(Collections.disjoint(solarSystemPart1, solarSystemPart2));

   }
}

Come puoi vedere, gli elementi nei nostri due elenchi sono completamente diversi, quindi il programma restituisce true. Questa è una lezione davvero interessante e molto utile. Ad esempio Arrays, fa molti lavori umili e di routine per noi, permettendoci di concentrarci su altre cose. Leggilo nella documentazione di Oracle , ci sono altri metodi lì.