Classe Collections in Java

CIAO! Nelle ultime lezioni, abbiamo fatto grandi progressi nella nostra padronanza di ArrayList. Tuttavia, finora abbiamo eseguito solo le operazioni più semplici: rimuovere, inserire e visualizzare. Naturalmente, questo non copre l'elenco completo delle attività che gli sviluppatori devono eseguire quando lavorano con ArrayList. Ricordi la lezione sugli array e la Arraysclasse? I creatori di Java hanno progettato specificamente questa classe per gestire le attività più comuni che i programmatori devono affrontare quando lavorano con gli array. E che mi dici diArrayList? Sicuramente, c'è un elenco di attività comuni che devono essere eseguite con esso. Sono stati tutti implementati in una classe specifica o dobbiamo scrivere la nostra implementazione ogni volta? Certo, non è necessario scrivere tutto da soli. Le operazioni più comuni che coinvolgono le raccolte sono già state implementate nella Collectionsclasse statica speciale. In Java, un gruppo di strutture di dati viene comunemente indicato come una raccolta . I dati possono essere archiviati in molti modi diversi. Finora abbiamo studiato solo la ArrayListclasse in cui i dati sono memorizzati in un array. Conosceremo altre collezioni in seguito. Per ora, è sufficiente capire che la Collectionsclasse è progettata per funzionare non solo conArrayList, ma anche con altri tipi di collezioni (da cui il nome). Quindi, con quali compiti Collectionsaiuta effettivamente la classe quando lavora ArrayList? Il primo e più ovvio è l'ordinamento. Nella lezione sugli array, abbiamo considerato un esempio con i numeri. Ora considereremo un esempio con le stringhe. La Collectionsclasse implementa il sort()metodo per ordinare i contenuti delle raccolte:

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

   }
}

Output: [Terra, Giove, Marte, Mercurio, Nettuno, Saturno, Urano, Venere] Le stringhe sono ordinate alfabeticamente! Ma perché in ordine alfabetico? La Stringclasse implementa effettivamente la logica che governa il modo in cui le stringhe vengono confrontate (che risulta essere in ordine alfabetico). Per le classi che crei tu stesso, puoi implementare la tua logica di confronto, ma ne parleremo in altre lezioni. La Collectionsclasse ti aiuta anche a trovare l'elemento minimo e massimo in un file ArrayList. Questo viene fatto usando 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));

}

Output: 7 1 Naturalmente, questo è molto più conveniente che scrivere manualmente il codice per iterare su tutti gli elementi e trovare l'elemento più grande/più piccolo :) Un altro metodo molto utile è reverse(). Se dovessimo "capovolgere" l'elenco in modo che gli elementi vadano nell'ordine opposto, come lo faremmo? Probabilmente non sarebbe così facile scrivere da soli un simile algoritmo :) Fortunatamente, il reverse()metodo sa già come. Supponiamo che non ci piaccia il fatto che il sort()metodo abbia ordinato i nostri pianeti in ordine alfabetico e vogliamo invertire il loro ordine: 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);

   }
}

Output: [Venere, Urano, Saturno, Nettuno, Mercurio, Marte, Giove, Terra] Abbiamo parlato molto dell'ordinamento, dell'ordine degli elementi, ecc. Ma se avessimo l'obiettivo opposto? Ad esempio, supponiamo di voler implementare un gioco del bingo. Aggiungiamo 100 numeri al tamburo. Dovrebbero apparire sullo schermo uno alla volta. Il primo giocatore a cancellare tutti i numeri sul suo biglietto vince. Questo è facile da implementare usando il shuffle()metodo:

public class Main {

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

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

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

       Collections.shuffle(bingoDrum);// Mix it up
       System.out.println ("Your attention, please! Here are the first 10 numbers from the drum!");
       for (int i = 0; i < 10; i++) {

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

   }
}

Uscita: La tua attenzione, per favore! Ecco i primi 10 numeri della batteria! 32 61 4 81 25 8 66 35 42 71 È così facile! Il problema è risolto e la nostra parte del gioco è scritta :) Ora immaginiamo una situazione diversa. In precedenza, abbiamo creato un solarSystemelenco che conteneva i pianeti. E sembra adattarsi a noi in tutti i modi tranne uno: puoi eliminare elementi da esso e aggiungerne di nuovi ! Questo chiaramente non è il comportamento che ci aspettiamo: il sistema solare dovrebbe essere immutabile nel nostro programma. La Collectionsclasse ha un metodo molto interessante: unmodifiableList(). Crea un elenco immutabile dall'elenco passato come argomento. Non puoi aggiungere o eliminare elementi da questo elenco. Quando si ha a che fare con l'elenco dei pianeti del sistema solare, questo è esattamente ciò che vogliamo!

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

Output: Eccezione nel thread "main" java.lang.UnsupportedOperationException in java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) in Main.main(Main.java:21) Questo è un errore: non puoi aggiungi qualcosa a solarSystem! L'unica cosa a cui devi prestare attenzione qui è il fatto che questo metodo restituisce List<>(non ArrayList<>), poiché questo tipo è comune a tutti i tipi di liste. Un'altra situazione abbastanza comune che può accadere facilmente è che il programmatore aggiunga elementi nell'ordine sbagliato. Se questo accade e scopriamo che Mercurio e Nettuno sono confusi, possiamo correggere questo errore usando il swap()metodo:

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));// The planets are in the wrong order
       System.out.println(solarSystem);

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

   }
}

Passiamo al swap()metodo la nostra lista e gli indici dei due elementi che devono essere scambiati. Si noti che il metodo funziona con gli indici, non con i riferimenti. Quindi, qui abbiamo dovuto usare il ArrayList.indexOf()metodo. Output: [Nettuno, Venere, Terra, Marte, Giove, Saturno, Urano, Mercurio] [Mercurio, Venere, Terra, Marte, Giove, Saturno, Urano, Nettuno] Infine, faremo conoscenza con un metodo molto interessante: disjoint(). Controlla se due collezioni si intersecano, cioè se hanno almeno un elemento identico . In caso contrario, restituisce true. Se lo fanno, allora restituisce falso

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, i nostri due elenchi hanno elementi completamente diversi, quindi il programma restituisce true . Questa è una classe interessante e molto utile. Ad esempio Arrays, fa un sacco di lavoro noioso e di routine per noi, permettendoci di concentrarci su altre cose.