Samlinger klasse i Java

Hei! I de siste timene har vi gjort store fremskritt i vår mestring av ArrayList. Men så langt har vi bare utført de enkleste operasjonene: fjerne, sette inn og vise. Dette dekker selvfølgelig ikke hele listen over oppgaver som utviklere må utføre når de jobber med ArrayList. Husker du leksjonen om arrays og Arraysklassen? Javas skapere designet spesielt denne klassen for å håndtere de vanligste oppgavene programmerere møter når de jobber med matriser. Og hva medArrayList? Det er sikkert en liste over vanlige oppgaver som må utføres med den. Har de alle blitt implementert i en bestemt klasse, eller må vi skrive vår egen implementering hver gang? Du trenger selvfølgelig ikke skrive alt selv. De vanligste operasjonene som involverer innkreving er allerede implementert i den spesielle statiske Collectionsklassen. I Java blir en gruppe datastrukturer ofte referert til som en samling . Data kan lagres på mange forskjellige måter. Så langt har vi kun studert ArrayListklassen, der data lagres i en matrise. Vi blir kjent med andre samlinger senere. Foreløpig er det nok å bare forstå at klassen Collectionser laget for å fungere ikke bare medArrayList, men også med andre typer samlinger (derav navnet). Så, hvilke oppgaver Collectionshjelper klassen egentlig med når de jobber med ArrayList? Det første og mest åpenbare er sortering. I leksjonen om matriser tok vi for oss et eksempel med tall. Nå skal vi vurdere et eksempel med strenger. Klassen Collectionsimplementerer sort()metoden for å sortere innholdet i samlinger:

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

   }
}

Utgang: [Jorden, Jupiter, Mars, Merkur, Neptun, Saturn, Uranus, Venus] Strengene er sortert alfabetisk! Men hvorfor alfabetisk? Klassen Stringimplementerer faktisk logikken som styrer hvordan strengene sammenlignes (som tilfeldigvis er alfabetisk). For klasser du lager selv, kan du implementere din egen sammenligningslogikk, men vi snakker om dette i andre leksjoner. Klassen Collectionshjelper deg også med å finne minimums- og maksimumselementet i en ArrayList. Dette gjøres ved å bruke min()og max()metodene:

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 Dette er naturligvis langt mer praktisk enn å manuelt skrive koden for å iterere over alle elementene og finne det største/minste elementet :) En annen veldig nyttig metode er reverse(). Hvis vi måtte "snu" listen slik at elementene gikk i motsatt rekkefølge, hvordan ville vi gjort det? Det ville nok ikke vært så lett å skrive en slik algoritme selv :) Heldigvis reverse()vet metoden allerede hvordan. Anta at vi ikke liker det faktum at metoden sort()sorterte planetene våre alfabetisk, og vi ønsker å snu rekkefølgen deres: fra Z til 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, Saturn, Neptun, Merkur, Mars, Jupiter, Jorden] Vi har snakket mye om sortering, rekkefølgen på elementene osv. Men hva om vi hadde det motsatte målet? Anta for eksempel at vi prøver å implementere et bingospill. Vi legger til 100 tall på trommelen. De skal vises på skjermen én om gangen. Den første spilleren som krysser ut alle tallene på sin billett vinner. Dette er enkelt å implementere ved hjelp av 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));
       }

   }
}

Utgang: Din oppmerksomhet, vær så snill! Her er de 10 første numrene fra trommelen! 32 61 4 81 25 8 66 35 42 71 Så enkelt er det! Problemet er løst, og vår del av spillet er skrevet :) La oss nå forestille oss en annen situasjon. Tidligere har vi laget en solarSystemliste som inneholdt planetene. Og det ser ut til å passe oss på alle måter bortsett fra én: du kan slette elementer fra det og legge til nye ! Dette er tydeligvis ikke oppførselen vi forventer: Solsystemet skal være uforanderlig i programmet vårt. Klassen Collectionshar en veldig interessant metode: unmodifiableList(). Den oppretter en uforanderlig liste fra listen som ble sendt som et argument. Du kan ikke legge til eller slette elementer fra denne listen. Når vi har å gjøre med listen over planeter i solsystemet, er det akkurat dette vi ønsker!

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: Unntak i tråden "main" java.lang.UnsupportedOperationException på java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) på Main.main(Main.java:21) Dette er en feil: du kan ikke legg til hva som helst solarSystem! Det eneste du trenger å være oppmerksom på her er det faktum at denne metoden returnerer List<>(ikke ArrayList<>), siden denne typen er vanlig for alle slags lister. En annen ganske vanlig situasjon som lett kan skje er at programmereren legger til elementer i feil rekkefølge. Hvis dette skjer og vi finner ut at Merkur og Neptun er blandet sammen, kan vi rette opp denne feilen ved å bruke 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 går over til swap()metoden vår liste og indeksene for de to elementene som må byttes. Merk at metoden fungerer med indekser, ikke referanser. Så, her måtte vi bruke ArrayList.indexOf()metoden. Utdata: [Neptun, Venus, Jorden, Mars, Jupiter, Saturn, Uranus, Merkur] [Merkur, Venus, Jorden, Mars, Jupiter, Saturn, Uranus, Neptun] Til slutt skal vi bli kjent med en veldig interessant metode: disjoint(). Den sjekker om to samlinger krysser hverandre, dvs. om de har minst ett identisk element . Hvis de ikke gjør det, returnerer det sant. Gjør de det, så returnerer 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åre to lister helt forskjellige elementer, så programmet gir ut sann . Dette er en interessant og veldig nyttig klasse. Som Arrays, det gjør mye rutinemessig, kjedelig arbeid for oss, og lar oss fokusere på andre ting.