Gyűjtemények osztály Java nyelven

Szia! Az elmúlt néhány leckében nagyot fejlődtünk a nyelv elsajátításában ArrayList. Eddig azonban csak a legegyszerűbb műveleteket hajtottuk végre: eltávolítás, beillesztés és megjelenítés. Természetesen ez nem fedi le azoknak a feladatoknak a teljes listáját, amelyeket a fejlesztőknek el kell végezniük, amikor a -val dolgoznak ArrayList. Emlékszel a tömbökről és az osztályról szóló leckére Arrays? A Java készítői kifejezetten úgy tervezték ezt az osztályt, hogy kezelje azokat a leggyakoribb feladatokat, amelyekkel a programozók szembesülnek, amikor tömbökkel dolgoznak. És mirőlArrayList? Bizonyára van néhány gyakori feladat, amelyet el kell végezni vele. Mindegyiket egy adott osztályban implementálták, vagy minden alkalommal meg kell írnunk a saját implementációnkat? Persze nem kell mindent magadnak megírnod. A legelterjedtebb gyűjteményekkel kapcsolatos műveleteket már a speciális statikus osztályban megvalósították Collections. A Java nyelvben az adatstruktúrák egy csoportját általában gyűjteménynek nevezik . Az adatok sokféle módon tárolhatók. Eddig csak azt az osztályt vizsgáltuk , ahol az adatok tömbben vannak tárolva. A többi kollekcióval később fogunk megismerkedni. Egyelőre elég csak megérteni, hogy az osztályt úgy tervezték, hogy ne csak vele dolgozzonArrayListCollectionsArrayList, hanem más típusú gyűjteményekkel is (innen a neve). Tehát milyen feladatokban Collectionssegít az osztály, amikor a -val dolgozik ArrayList? Az első és legnyilvánvalóbb a válogatás. A tömbökről szóló leckében egy példát vettünk figyelembe számokkal. Most megvizsgálunk egy példát a karakterláncokkal. Az Collectionsosztály sort()a gyűjtemények tartalmának rendezésére szolgáló metódust valósítja meg:

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

   }
}

Kimenet: [Föld, Jupiter, Mars, Merkúr, Neptunusz, Szaturnusz, Uránusz, Vénusz] A húrok ábécé szerint vannak rendezve! De miért ábécé sorrendben? Az Stringosztály valójában azt a logikát valósítja meg, amely szabályozza a karakterláncok összehasonlítását (ami történetesen ábécé sorrendben történik). A saját maga által létrehozott osztályok esetében megvalósíthatja saját összehasonlítási logikáját, de erről más leckékben fogunk beszélni. Az Collectionsosztály segít megtalálni a minimális és maximális elemet egy ArrayList. min()Ez a és módszerekkel történik 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));

}

Kimenet: 7 1 Természetesen ez sokkal kényelmesebb, mint manuálisan beírni a kódot, hogy az összes elemet átiterálva megkeressük a legnagyobb/legkisebb elemet :) Egy másik nagyon hasznos módszer a reverse(). Ha úgy kellene "fordítanunk" a listát, hogy az elemek ellenkező sorrendben menjenek, hogyan tennénk? Valószínűleg nem lenne olyan egyszerű egyedül megírni egy ilyen algoritmust :) Szerencsére a reverse()módszer már tudja, hogyan kell. Tegyük fel, hogy nem tetszik nekünk, hogy a sort()módszer ábécé szerint rendezte bolygónkat, és meg akarjuk fordítani a sorrendjüket: Z-ről A-ra:

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

   }
}

Kimenet: [Vénusz, Uránusz, Szaturnusz, Neptunusz, Merkúr, Mars, Jupiter, Föld] Sokat beszéltünk a rendezésről, az elemek sorrendjéről stb. De mi van, ha ellenkező célt tűztünk ki magunk elé? Tegyük fel például, hogy egy bingójátékot próbálunk megvalósítani. 100 számot adunk a dobhoz. Egyenként kell megjelenniük a képernyőn. Az a játékos nyer, aki először áthúzza a jegyében szereplő összes számot. Ez könnyen megvalósítható a shuffle()következő módszerrel:

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

   }
}

Kimenet: Kérem a figyelmet! Íme az első 10 szám a dobból! 32 61 4 81 25 8 66 35 42 71 Ilyen egyszerű! A probléma megoldva, a mi játékrészünk meg van írva :) Most képzeljünk el egy másik szituációt. Korábban létrehoztunk egy solarSystemlistát, amely a bolygókat tartalmazza. És úgy tűnik, egy kivételével mindenben megfelel nekünk: törölhet belőle elemeket, és hozzáadhat újakat ! Nyilvánvalóan nem ezt a viselkedést várjuk: A naprendszernek változhatatlannak kell lennie a programunkban. Az Collectionsosztálynak van egy nagyon érdekes módszere: unmodifiableList(). Az argumentumként átadott listából megváltoztathatatlan listát hoz létre. Nem adhat hozzá vagy törölhet elemeket ebből a listából. Amikor a Naprendszer bolygóinak listájával foglalkozunk, pontosan ezt akarjuk!

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

Kimenet: Kivétel a "main" szálban java.lang.UnsupportedOperationException itt: java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) itt: Main.main(Main.java:21) Ez egy hiba: nem lehet adj hozzá bármit solarSystem! Itt csak arra kell figyelni, hogy ez a metódus List<>(nem ArrayList<>) ad vissza, mivel ez a típus minden listára jellemző. Egy másik nagyon gyakori helyzet, ami könnyen előfordulhat, hogy a programozó rossz sorrendben adja hozzá az elemeket. Ha ez megtörténik, és azt találjuk, hogy a Merkúr és a Neptunusz összekeveredik, akkor ezt a hibát a következő módszerrel javíthatjuk 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);

   }
}

Áttérünk a swap()metódushoz a listánkat és a két cserélni kívánt elem indexét. Vegye figyelembe, hogy a módszer indexekkel működik, nem hivatkozásokkal. Tehát itt a módszert kellett használnunk ArrayList.indexOf(). Kimenet: [Neptunusz, Vénusz, Föld, Mars, Jupiter, Szaturnusz, Uránusz, Merkúr] [Merkúr, Vénusz, Föld, Mars, Jupiter, Szaturnusz, Uránusz, Neptunusz] Végül egy nagyon érdekes módszerrel ismerkedünk meg: disjoint(). Ellenőrzi, hogy két gyűjtemény metszi-e egymást, azaz van-e legalább egy azonos eleme . Ha nem teszik meg, akkor igazat ad vissza. Ha megteszik, akkor hamisan tér vissza

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

   }
}

Amint látható, a két listánk teljesen eltérő elemekkel rendelkezik, így a program true -ot ad ki . Ez egy érdekes és nagyon hasznos óra. Mint például Arrays, ez sok rutinszerű, fárasztó munkát végez értünk, lehetővé téve, hogy más dolgokra koncentráljunk.