Samlingsklass i Java

Hej! Under de senaste lektionerna har vi gjort stora framsteg i vår behärskning av ArrayList. Men hittills har vi bara utfört de enklaste operationerna: ta bort, infoga och visa. Naturligtvis täcker detta inte hela listan över uppgifter som utvecklare måste utföra när de arbetar med ArrayList. Kommer du ihåg lektionen om arrayer och Arraysklassen? Javas skapare utformade specifikt den här klassen för att hantera de vanligaste uppgifterna som programmerare möter när de arbetar med arrayer. Och vad sägs omArrayList? Det finns säkert en lista över vanliga uppgifter som måste utföras med den. Har de alla implementerats i en specifik klass, eller måste vi skriva vår egen implementering varje gång? Du behöver förstås inte skriva allt själv. De vanligaste operationerna som involverar insamlingar har redan implementerats i den särskilda statiska Collectionsklassen. I Java kallas en grupp datastrukturer vanligtvis för en samling . Data kan lagras på många olika sätt. Hittills har vi bara studerat ArrayListklassen, där data lagras i en array. Vi kommer att bekanta oss med andra samlingar senare. För nu räcker det att bara förstå att Collectionsklassen är designad för att fungera inte bara medArrayList, men också med andra typer av samlingar (därav dess namn). Så, vilka uppgifter Collectionshjälper klassen egentligen med när man arbetar med ArrayList? Det första och mest uppenbara är sortering. I lektionen om arrayer övervägde vi ett exempel med siffror. Nu ska vi överväga ett exempel med strängar. Klassen Collectionsimplementerar sort()metoden för att sortera innehållet i samlingar:

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

   }
}

Utdata: [Jorden, Jupiter, Mars, Merkurius, Neptunus, Saturnus, Uranus, Venus] Strängarna är sorterade i alfabetisk ordning! Men varför alfabetiskt? Klassen Stringimplementerar faktiskt logiken som styr hur strängarna jämförs (vilket råkar vara alfabetiskt). För klasser som du skapar själv kan du implementera din egen jämförelselogik, men vi kommer att prata om detta i andra lektioner. Klassen Collectionshjälper dig också att hitta minimum- och maximumelementet i en ArrayList. Detta görs med hjälp av min()och max()metoderna:

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

}

Utdata: 7 1 Naturligtvis är detta mycket bekvämare än att manuellt skriva koden för att iterera över alla element och hitta det största/minsta elementet :) En annan mycket användbar metod är reverse(). Om vi ​​var tvungna att "vända" listan så att elementen gick i motsatt ordning, hur skulle vi göra det? Det skulle nog inte vara så lätt att skriva en sådan algoritm själv :) Lyckligtvis reverse()vet metoden redan hur. Anta att vi inte gillar det faktum att sort()metoden sorterade våra planeter alfabetiskt, och vi vill vända deras ordning: från Z till 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);

   }
}

Utdata: [Venus, Uranus, Saturnus, Neptunus, Merkurius, Mars, Jupiter, Jorden] Vi har pratat mycket om sortering, ordningen på elementen, etc. Men tänk om vi hade det motsatta målet? Anta till exempel att vi försöker implementera ett bingospel. Vi lägger till 100 nummer på trumman. De bör visas på skärmen en i taget. Den första spelaren som stryker över alla siffror på sin biljett vinner. Detta är lätt att implementera med shuffle()metoden:

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

   }
}

Utgång: Din uppmärksamhet, tack! Här är de 10 första numren från trumman! 32 61 4 81 25 8 66 35 42 71 Så enkelt är det! Problemet är löst, och vår del av spelet är skriven :) Låt oss nu föreställa oss en annan situation. Tidigare skapade vi en solarSystemlista som innehöll planeterna. Och det verkar passa oss på alla sätt utom ett: du kan ta bort objekt från den och lägga till nya ! Detta är helt klart inte det beteende vi förväntar oss: Solsystemet borde vara oföränderligt i vårt program. Klassen Collectionshar en mycket intressant metod: unmodifiableList(). Den skapar en oföränderlig lista från listan som skickas som ett argument. Du kan inte lägga till eller ta bort objekt från den här listan. När vi har att göra med listan över planeter i solsystemet är det precis det vi vill ha!

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

Utdata: Undantag i tråden "main" java.lang.UnsupportedOperationException på java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) på Main.main(Main.java:21) Detta är ett fel: du kan inte lägga till vad som helst solarSystem! Det enda du behöver vara uppmärksam på här är det faktum att denna metod returnerar List<>(inte ArrayList<>), eftersom denna typ är vanlig för alla typer av listor. En annan ganska vanlig situation som lätt kan inträffa är att programmeraren lägger till element i fel ordning. Om detta händer och vi upptäcker att Merkurius och Neptunus blandas ihop, kan vi rätta till detta misstag med metoden 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));// The planets are in the wrong order
       System.out.println(solarSystem);

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

   }
}

Vi övergår till swap()metoden vår lista och indexen för de två element som måste bytas. Observera att metoden fungerar med index, inte referenser. Så här var vi tvungna att använda ArrayList.indexOf()metoden. Utdata: [Neptunus, Venus, Jorden, Mars, Jupiter, Saturnus, Uranus, Merkurius] [Mercury, Venus, Jorden, Mars, Jupiter, Saturnus, Uranus, Neptunus] Slutligen ska vi bekanta oss med en mycket intressant metod: disjoint(). Den kontrollerar om två samlingar skär varandra, dvs om de har minst ett identiskt element . Om de inte gör det, återgår det sant. Om de gör det, då returnerar det falskt

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

   }
}

Som du kan se har våra två listor helt olika element, så programmet matar ut sant . Detta är en intressant och mycket användbar klass. Som att Arraysdet gör mycket rutinmässigt, tråkigt arbete för oss, och låter oss fokusera på andra saker.