Clasa de colecții în Java

Bună! În ultimele câteva lecții, am făcut progrese mari în stăpânirea ArrayList. Cu toate acestea, până acum am efectuat doar cele mai simple operații: ștergeți, inserați și afișați. Desigur, aceasta nu acoperă lista completă de sarcini pe care dezvoltatorii trebuie să le îndeplinească atunci când lucrează cu ArrayList. Vă amintiți lecția despre matrice și Arraysclasă? Creatorii Java au conceput special această clasă pentru a gestiona cele mai comune sarcini cu care se confruntă programatorii atunci când lucrează cu matrice. Și ce ziciArrayList? Cu siguranță, există o listă de sarcini comune care trebuie efectuate cu acesta. Au fost toate implementate într-o anumită clasă sau trebuie să scriem propria noastră implementare de fiecare dată? Desigur, nu trebuie să scrieți totul singur. Cele mai comune operațiuni care implică colecții au fost deja implementate în Collectionsclasa statică specială. În Java, un grup de structuri de date este denumit în mod obișnuit o colecție . Datele pot fi stocate în multe moduri diferite. Până acum, am studiat doar ArrayListclasa, unde datele sunt stocate într-o matrice. Ne vom familiariza cu alte colecții mai târziu. Deocamdată, este suficient să înțelegem că Collectionsclasa este concepută să funcționeze nu numai cuArrayList, dar și cu alte tipuri de colecții (de unde și denumirea acestuia). Deci, cu ce sarcini Collectionsajută clasa de fapt atunci când lucrează ArrayList? Prima și cea mai evidentă este sortarea. În lecția despre matrice, am luat în considerare un exemplu cu numere. Acum vom lua în considerare un exemplu cu șiruri. Clasa Collectionsimplementează sort()metoda de sortare a conținutului colecțiilor:

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

   }
}

Ieșire: [Pământ, Jupiter, Marte, Mercur, Neptun, Saturn, Uranus, Venus] Șirurile sunt sortate alfabetic! Dar de ce alfabetic? Clasa Stringimplementează de fapt logica care guvernează modul în care sunt comparate șirurile (care se întâmplă să fie alfabetic). Pentru clasele pe care le creați singur, vă puteți implementa propria logică de comparație, dar despre asta vom vorbi în alte lecții. De asemenea, clasa Collectionsvă ajută să găsiți elementul minim și maxim într-un ArrayList. Acest lucru se face folosind metodele min()și 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));

}

Ieșire: 7 1 Desigur, acest lucru este mult mai convenabil decât scrierea manuală a codului pentru a repeta peste toate elementele și a găsi cel mai mare/cel mai mic element :) O altă metodă foarte utilă este reverse(). Dacă ar trebui să „întoarcem” lista astfel încât elementele să meargă în ordine opusă, cum am proceda? Probabil că nu ar fi atât de ușor să scrii singur un astfel de algoritm :) Din fericire, metoda reverse()știe deja cum. Să presupunem că nu ne place faptul că sort()metoda ne-a sortat planetele alfabetic și vrem să inversăm ordinea lor: de la Z la 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);

   }
}

Ieșire: [Venus, Uranus, Saturn, Neptun, Mercur, Marte, Jupiter, Pământ] Am tot vorbit despre sortare, ordinea elementelor etc. Dar dacă am avea obiectivul opus? De exemplu, să presupunem că încercăm să implementăm un joc de bingo. Adăugăm 100 de numere la tobă. Ar trebui să apară pe ecran pe rând. Câștigă primul jucător care taie toate numerele de pe bilet. Acest lucru este ușor de implementat folosind shuffle()metoda:

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

   }
}

Ieșire: Atenția dumneavoastră, vă rog! Iată primele 10 numere de la tobă! 32 61 4 81 25 8 66 35 42 71 Este atât de ușor! Problema este rezolvată, iar partea noastră din joc este scrisă :) Acum să ne imaginăm o situație diferită. Anterior, am creat o solarSystemlistă care conținea planetele. Și se pare că ni se potrivește din toate punctele de vedere, cu excepția unuia: puteți șterge articole din el și puteți adăuga altele noi ! În mod clar, acesta nu este comportamentul la care ne așteptăm: sistemul solar ar trebui să fie neschimbabil în programul nostru. Clasa Collectionsare o metodă foarte interesantă: unmodifiableList(). Acesta creează o listă imuabilă din lista transmisă ca argument. Nu puteți adăuga sau șterge elemente din această listă. Când avem de-a face cu lista planetelor din sistemul solar, asta este exact ceea ce ne dorim!

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

Ieșire: Excepție în firul „main” java.lang.UnsupportedOperationException la java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) la Main.main(Main.java:21) Aceasta este o eroare: nu puteți adauga orice la solarSystem! Singurul lucru pe care trebuie să-l acordați atenție aici este faptul că această metodă returnează List<>(nu ArrayList<>), deoarece acest tip este comun pentru toate tipurile de liste. O altă situație destul de comună care se poate întâmpla cu ușurință este ca programatorul să adauge elemente în ordine greșită. Dacă se întâmplă acest lucru și constatăm că Mercur și Neptun sunt amestecate, putem corecta această greșeală folosind swap()metoda:

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

   }
}

Trecem la swap()metoda lista noastră și indicii celor două elemente care trebuie schimbate. Rețineți că metoda funcționează cu indici, nu cu referințe. Deci, aici a trebuit să folosim ArrayList.indexOf()metoda. Ieșire: [Neptun, Venus, Pământ, Marte, Jupiter, Saturn, Uranus, Mercur] [Mercur, Venus, Pământ, Marte, Jupiter, Saturn, Uranus, Neptun] În sfârșit, ne vom familiariza cu o metodă foarte interesantă: disjoint(). Se verifică dacă două colecții se intersectează, adică dacă au cel puțin un element identic . Dacă nu, se întoarce adevărat. Dacă o fac, atunci se întoarce fals

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

   }
}

După cum puteți vedea, cele două liste ale noastre au elemente complet diferite, așa că programul arată true . Aceasta este o clasă interesantă și foarte utilă. De exemplu Arrays, face o mulțime de muncă de rutină și plictisitoare pentru noi, lăsându-ne să ne concentrăm asupra altor lucruri.