Klasa Collections w Javie

Cześć! W ciągu ostatnich kilku lekcji poczyniliśmy ogromne postępy w opanowaniu języka ArrayList. Jednak do tej pory wykonywaliśmy tylko najprostsze operacje: usuwanie, wstawianie i wyświetlanie. Oczywiście nie obejmuje to pełnej listy zadań, które programiści muszą wykonać podczas pracy z platformą ArrayList. Pamiętasz lekcję o tablicach i Arraysklasie? Twórcy Javy specjalnie zaprojektowali tę klasę do obsługi najczęstszych zadań, przed którymi stają programiści podczas pracy z tablicami. A co zArrayList? Z pewnością istnieje lista typowych zadań, które należy z nim wykonać. Czy wszystkie zostały zaimplementowane w konkretnej klasie, czy też musimy za każdym razem pisać własną implementację? Oczywiście nie musisz wszystkiego pisać sam. W specjalnej klasie statycznej zostały już zaimplementowane najczęstsze operacje na kolekcjach Collections. W języku Java grupa struktur danych jest powszechnie nazywana kolekcją . Dane mogą być przechowywane na wiele różnych sposobów. Do tej pory badaliśmy tylko ArrayListklasę, w której dane są przechowywane w tablicy. Z innymi kolekcjami zapoznamy się później. Na razie wystarczy zrozumieć, że Collectionsklasa jest przeznaczona do pracy nie tylko zArrayList, ale także z innymi rodzajami kolekcji (stąd jego nazwa). W jakich zadaniach ta Collectionsklasa faktycznie pomaga podczas pracy z ArrayList? Pierwszym i najbardziej oczywistym jest sortowanie. W lekcji o tablicach rozważaliśmy przykład z liczbami. Teraz rozważymy przykład z łańcuchami. Klasa Collectionsimplementuje sort()metodę sortowania zawartości kolekcji:

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

   }
}

Wyjście: [Ziemia, Jowisz, Mars, Merkury, Neptun, Saturn, Uran, Wenus] Ciągi są posortowane alfabetycznie! Ale dlaczego alfabetycznie? Klasa Stringfaktycznie implementuje logikę, która reguluje sposób porównywania łańcuchów (co zdarza się alfabetycznie). W przypadku klas, które sam tworzysz, możesz zaimplementować własną logikę porównania, ale omówimy to w innych lekcjach. Klasa Collectionspomaga również znaleźć minimalny i maksymalny element w pliku ArrayList. Odbywa się to za pomocą metod 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));

}

Wynik: 7 1 Oczywiście jest to o wiele wygodniejsze niż ręczne pisanie kodu w celu iteracji wszystkich elementów i znalezienia największego/najmniejszego elementu :) Inną bardzo przydatną metodą jest reverse(). Gdybyśmy musieli „odwrócić” listę, aby elementy poszły w odwrotnej kolejności, jak byśmy to zrobili? Chyba nie byłoby tak łatwo samemu napisać taki algorytm :) Na szczęście metoda reverse()już wie jak to zrobić. Załóżmy, że nie podoba nam się, że sort()metoda posortowała nasze planety alfabetycznie i chcemy odwrócić ich kolejność: od Z do 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);

   }
}

Wyjście: [Wenus, Uran, Saturn, Neptun, Merkury, Mars, Jowisz, Ziemia] Dużo rozmawialiśmy o sortowaniu, kolejności elementów itp. Ale co by było, gdybyśmy mieli przeciwny cel? Załóżmy na przykład, że próbujemy zaimplementować grę bingo. Do bębna dodajemy 100 numerów. Powinny pojawiać się na ekranie pojedynczo. Pierwszy gracz, który skreśli wszystkie cyfry na swoim bilecie, wygrywa. Jest to łatwe do wdrożenia za pomocą shuffle()metody:

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

   }
}

Wyjście: Proszę o uwagę! Oto pierwsze 10 numerów z bębna! 32 61 4 81 25 8 66 35 42 71 To takie proste! Problem rozwiązany, a nasza część gry napisana :) Teraz wyobraźmy sobie inną sytuację. Wcześniej utworzyliśmy solarSystemlistę zawierającą planety. I wydaje się nam pasować pod każdym względem oprócz jednego: możesz usuwać z niego elementy i dodawać nowe ! Z pewnością nie jest to zachowanie, jakiego oczekujemy: Układ Słoneczny powinien być niezmienny w naszym programie. Klasa Collectionsma bardzo interesującą metodę: unmodifiableList(). Tworzy niezmienną listę z listy przekazanej jako argument. Nie możesz dodawać ani usuwać elementów z tej listy. Kiedy mamy do czynienia z listą planet w Układzie Słonecznym, właśnie tego chcemy!

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

Dane wyjściowe: Wyjątek w wątku „main” java.lang.UnsupportedOperationException w java.util.Collections$UnmodifyingCollection.add(Collections.java:1075) w Main.main(Main.java:21) To jest błąd: nie można dodać cokolwiek solarSystem! Jedyne na co trzeba tutaj zwrócić uwagę to fakt, że ta metoda zwraca List<>(nie ArrayList<>), ponieważ ten typ jest wspólny dla wszystkich rodzajów list. Inną dość częstą sytuacją, która może się łatwo zdarzyć, jest dodawanie przez programistę elementów w niewłaściwej kolejności. Jeśli tak się stanie i stwierdzimy, że Merkury i Neptun są pomieszane, możemy naprawić ten błąd za pomocą swap()metody:

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

   }
}

Do metody przekazujemy swap()naszą listę oraz indeksy dwóch elementów, które mają zostać zamienione. Zauważ, że metoda działa z indeksami, a nie referencjami. Więc tutaj musieliśmy użyć ArrayList.indexOf()metody. Wyjście: [Neptun, Wenus, Ziemia, Mars, Jowisz, Saturn, Uran, Merkury] [Merkury, Wenus, Ziemia, Mars, Jowisz, Saturn, Uran, Neptun] Na koniec zapoznamy się z bardzo ciekawą metodą: disjoint(). Sprawdza, czy dwa zbiory się przecinają, tzn. czy mają przynajmniej jeden identyczny element . Jeśli nie, zwraca wartość true. Jeśli to zrobią, to zwraca wartość false

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

   }
}

Jak widać, nasze dwie listy mają zupełnie inne elementy, więc program zwraca true . To ciekawa i bardzo przydatna lekcja. Na przykład Arrayswykonuje za nas dużo rutynowej, żmudnej pracy, pozwalając nam skupić się na innych rzeczach.