Samlinger klasse i Java

Hej! I de sidste par lektioner har vi gjort store fremskridt i vores beherskelse af ArrayList. Men indtil videre har vi kun udført de enkleste handlinger: fjerne, indsætte og vise. Dette dækker naturligvis ikke hele listen over opgaver, som udviklere skal udføre, når de arbejder med ArrayList. Kan du huske lektionen om arrays og Arraysklassen? Javas skabere designet specifikt denne klasse til at håndtere de mest almindelige opgaver, programmører står over for, når de arbejder med arrays. Og hvad medArrayList? Der er helt sikkert en liste over almindelige opgaver, der skal udføres med den. Er de alle blevet implementeret i en bestemt klasse, eller skal vi skrive vores egen implementering hver gang? Du behøver selvfølgelig ikke skrive alt selv. De mest almindelige operationer, der involverer indsamlinger, er allerede implementeret i den særlige statiske Collectionsklasse. I Java omtales en gruppe af datastrukturer almindeligvis som en samling . Data kan lagres på mange forskellige måder. Indtil videre har vi kun studeret ArrayListklassen, hvor data er gemt i et array. Vi stifter bekendtskab med andre samlinger senere. For nu er det nok bare at forstå, at klassen Collectionser designet til at fungere ikke kun medArrayList, men også med andre typer samlinger (deraf navnet). Så hvilke opgaver Collectionshjælper klassen egentlig med, når de arbejder med ArrayList? Den første og mest oplagte er sortering. I lektionen om arrays betragtede vi et eksempel med tal. Nu vil vi overveje et eksempel med strenge. Klassen Collectionsimplementerer sort()metoden til at sortere indholdet af 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);

   }
}

Output: [Jorden, Jupiter, Mars, Merkur, Neptun, Saturn, Uranus, Venus] Strengene er sorteret alfabetisk! Men hvorfor alfabetisk? Klassen Stringimplementerer faktisk den logik, der styrer, hvordan strengene sammenlignes (som tilfældigvis er alfabetisk). For klasser, som du selv opretter, kan du implementere din egen sammenligningslogik, men det vil vi tale om i andre lektioner. Klassen Collectionshjælper dig også med at finde minimums- og maksimumselementet i en ArrayList. Dette gøres ved hjælp af min()og max()metoderne:

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 mere praktisk end manuelt at skrive koden for at iterere over alle elementerne og finde det største/mindste element :) En anden meget nyttig metode er reverse(). Hvis vi skulle "vende" listen, så elementerne gik i modsat rækkefølge, hvordan ville vi så gøre det? Det ville nok ikke være så nemt at skrive sådan en algoritme selv :) Heldigvis ved metoden reverse()allerede hvordan. Antag, at vi ikke kan lide det faktum, at sort()metoden sorterede vores planeter alfabetisk, og vi ønsker at vende deres rækkefølge: 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);

   }
}

Output: [Venus, Uranus, Saturn, Neptun, Merkur, Mars, Jupiter, Jorden] Vi har talt meget om sortering, rækkefølgen af ​​grundstofferne osv. Men hvad nu hvis vi havde det modsatte mål? Antag for eksempel, at vi forsøger at implementere et bingospil. Vi tilføjer 100 numre til tromlen. De skal vises på skærmen én ad gangen. Den første spiller, der krydser alle numrene på sin billet, vinder. Dette er nemt at implementere ved hjælp af 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));
       }

   }
}

Output: Din opmærksomhed, tak! Her er de første 10 numre fra trommen! 32 61 4 81 25 8 66 35 42 71 Så nemt er det! Problemet er løst, og vores del af spillet er skrevet :) Lad os nu forestille os en anden situation. Tidligere lavede vi en solarSystemliste, der indeholdt planeterne. Og det ser ud til at passe os på alle måder undtagen én: du kan slette elementer fra det og tilføje nye ! Dette er tydeligvis ikke den adfærd, vi forventer: Solsystemet skulle være uforanderligt i vores program. Klassen Collectionshar en meget interessant metode: unmodifiableList(). Det opretter en uforanderlig liste fra listen, der er sendt som et argument. Du kan ikke tilføje eller slette elementer fra denne liste. Når vi beskæftiger os med listen over planeter i solsystemet, er det præcis det, 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
   }
}

Output: Undtagelse 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 fejl: du kan ikke tilføje noget til solarSystem! Det eneste du skal være opmærksom på her er, at denne metode returnerer List<>(ikke ArrayList<>), da denne type er almindelig for alle slags lister. En anden ganske almindelig situation, der nemt kan ske, er, at programmøren tilføjer elementer i den forkerte rækkefølge. Hvis dette sker, og vi opdager, at Merkur og Neptun er blandet sammen, kan vi rette denne fejl ved hjælp af swap()metoden:

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 videregiver til swap()metoden vores liste og indekserne for de to elementer, der skal byttes. Bemærk, at metoden fungerer med indekser, ikke referencer. Så her måtte vi bruge ArrayList.indexOf()metoden. Output: [Neptun, Venus, Jorden, Mars, Jupiter, Saturn, Uranus, Merkur] [Merkur, Venus, Jorden, Mars, Jupiter, Saturn, Uranus, Neptun] Til sidst vil vi stifte bekendtskab med en meget interessant metode: disjoint(). Den kontrollerer, om to samlinger skærer hinanden, dvs. om de har mindst ét ​​identisk element . Hvis de ikke gør det, vender det tilbage. Gør de det, så returnerer det falsk

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 vores to lister helt forskellige elementer, så programmet udsender sand . Dette er en interessant og meget nyttig klasse. Ligesom Arraysdet gør en masse rutinemæssigt, kedeligt arbejde for os, og lader os fokusere på andre ting.