Collectieklasse in Java

Hoi! In de afgelopen paar lessen hebben we grote vooruitgang geboekt in het beheersen van ArrayList. Tot nu toe hebben we echter alleen de eenvoudigste bewerkingen uitgevoerd: verwijderen, invoegen en weergeven. Dit dekt natuurlijk niet de volledige lijst met taken die ontwikkelaars moeten uitvoeren bij het werken met ArrayList. Herinner je je de les over arrays en de Arraysklasse nog? De makers van Java hebben deze klasse speciaal ontworpen om de meest voorkomende taken uit te voeren waarmee programmeurs worden geconfronteerd bij het werken met arrays. En wat denk je vanArrayList? Er is zeker een lijst met veelvoorkomende taken die ermee moeten worden uitgevoerd. Zijn ze allemaal geïmplementeerd in een specifieke klasse, of moeten we elke keer onze eigen implementatie schrijven? Je hoeft natuurlijk niet alles zelf te schrijven. De meest voorkomende bewerkingen met verzamelingen zijn al geïmplementeerd in de speciale statische Collectionsklasse. In Java wordt een groep gegevensstructuren gewoonlijk een verzameling genoemd . Gegevens kunnen op veel verschillende manieren worden opgeslagen. Tot nu toe hebben we alleen de klasse bestudeerd, waar gegevens in een array worden opgeslagen. We zullen later kennis maken met andere collecties. Voor nu is het voldoende om gewoon te begrijpen dat de klas is ontworpen om niet alleen mee te werkenArrayListCollectionsArrayList, maar ook met andere soorten collecties (vandaar de naam). Dus, met welke taken Collectionshelpt de klas eigenlijk bij het werken met ArrayList? De eerste en meest voor de hand liggende is sorteren. In de les over arrays hebben we een voorbeeld met getallen behandeld. Nu bekijken we een voorbeeld met strings. De Collectionsklasse implementeert de sort()methode voor het sorteren van de inhoud van collecties:

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

   }
}

Uitvoer: [Aarde, Jupiter, Mars, Mercurius, Neptunus, Saturnus, Uranus, Venus] De strings zijn alfabetisch gesorteerd! Maar waarom alfabetisch? De Stringklasse implementeert eigenlijk de logica die bepaalt hoe de strings worden vergeleken (wat toevallig alfabetisch is). Voor klassen die u zelf maakt, kunt u uw eigen vergelijkingslogica implementeren, maar daar zullen we het in andere lessen over hebben. De Collectionsklasse helpt u ook bij het vinden van het minimale en maximale element in een ArrayList. Dit wordt gedaan met behulp van de methoden min()en 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));

}

Uitvoer: 7 1 Dit is natuurlijk veel handiger dan het handmatig schrijven van de code om alle elementen te herhalen en het grootste/kleinste element te vinden :) Een andere zeer bruikbare methode is reverse(). Als we de lijst moesten "omdraaien" zodat de elementen in de tegenovergestelde volgorde zouden staan, hoe zouden we dat dan doen? Het zou waarschijnlijk niet zo eenvoudig zijn om zelf zo'n algoritme te schrijven :) Gelukkig reverse()weet de methode al hoe. Stel dat het ons niet bevalt dat de sort()methode onze planeten alfabetisch sorteert, en we willen hun volgorde omdraaien: van Z naar 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);

   }
}

Uitvoer: [Venus, Uranus, Saturnus, Neptunus, Mercurius, Mars, Jupiter, Aarde] We hebben veel gepraat over sorteren, de volgorde van de elementen, enz. Maar wat als we het tegenovergestelde doel hadden? Stel dat we een bingospel proberen te implementeren. We voegen 100 nummers toe aan de trommel. Ze moeten één voor één op het scherm verschijnen. De eerste speler die alle nummers op zijn ticket heeft doorgestreept, wint. Dit is eenvoudig te implementeren met behulp van de shuffle()methode:

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

   }
}

Uitvoer: Uw aandacht alstublieft! Hier zijn de eerste 10 nummers van de trommel! 32 61 4 81 25 8 66 35 42 71 Zo eenvoudig is het! Het probleem is opgelost en ons deel van het spel is geschreven :) Laten we ons nu een andere situatie voorstellen. Eerder maakten we een solarSystemlijst met de planeten. En het lijkt in alle opzichten bij ons te passen, behalve één: je kunt er items uit verwijderen en nieuwe toevoegen ! Dit is duidelijk niet het gedrag dat we verwachten: het zonnestelsel zou onveranderlijk moeten zijn in ons programma. De Collectionsklas heeft een zeer interessante methode: unmodifiableList(). Het creëert een onveranderlijke lijst van de lijst die als argument is doorgegeven. U kunt geen items toevoegen aan of verwijderen uit deze lijst. Als we te maken hebben met de lijst met planeten in het zonnestelsel, is dit precies wat we willen!

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

Uitvoer: Uitzondering in thread "main" java.lang.UnsupportedOperationException op java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) op Main.main(Main.java:21) Dit is een fout: dat kan niet voeg iets toe aan solarSystem! Het enige waar je hier op moet letten is het feit dat deze methode retourneert List<>(niet ArrayList<>), aangezien dit type gebruikelijk is voor allerlei soorten lijsten. Een andere veel voorkomende situatie die gemakkelijk kan gebeuren, is dat de programmeur elementen in de verkeerde volgorde toevoegt. Als dit gebeurt en we ontdekken dat Mercurius en Neptunus door elkaar zijn gehaald, kunnen we deze fout corrigeren met behulp van de swap()methode:

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

   }
}

We geven swap()onze lijst en de indices van de twee elementen die moeten worden verwisseld door aan de methode. Merk op dat de methode werkt met indices, niet met referenties. Dus hier moesten we de ArrayList.indexOf()methode gebruiken. Uitvoer: [Neptunus, Venus, Aarde, Mars, Jupiter, Saturnus, Uranus, Mercurius] [Mercurius, Venus, Aarde, Mars, Jupiter, Saturnus, Uranus, Neptunus] Tot slot maken we kennis met een zeer interessante methode: disjoint(). Het controleert of twee collecties elkaar snijden, dwz of ze minstens één identiek element hebben . Als dat niet het geval is, wordt true geretourneerd. Als ze dat doen, geeft het false terug

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

   }
}

Zoals je kunt zien, hebben onze twee lijsten totaal verschillende elementen, dus het programma voert true uit . Dit is een interessante en zeer nuttige les. Zoals Arrays, het doet veel routinematig, vervelend werk voor ons, waardoor we ons op andere dingen kunnen concentreren.