Kolekcje w Javie | Kolekcje Javy

Cześć! W ciągu ostatnich kilku lekcji poczyniliśmy ogromne postępy w opanowaniu ArrayList. Jednak w tym czasie wykonaliśmy tylko najprostsze operacje: usuwanie, wstawianie, wysyłanie do konsoli. To oczywiście nie koniec listy problemów, z jakimi borykają się programiści korzystając z ArrayList . Pamiętacie wykład o tablicach i klasie Arrays ? Został opracowany przez twórców Javy specjalnie w celu rozwiązywania typowych problemów, jakie napotykają programiści podczas pracy z tablicami. A co z ArrayList ? Z pewnością jest też dla niego jakaś lista typowych zadań. Czy wszystkie zostały zaimplementowane w jakiejś osobnej klasie, czy też będziemy musieli za każdym razem ręcznie pisać pożądane zachowanie? Oczywiście nie musisz pisać wszystkiego sam. Najczęstsze operacje jakie są wykonywane podczas korzystania z kolekcji w Javie zostały już zaimplementowane w specjalnej klasie statycznej Collections.

Kolekcje w Javie

„Kolekcje” to ogólna nazwa kilku struktur danych w Javie. Dane można przechowywać na wiele różnych sposobów. Do tej pory badaliśmy tylko klasę ArrayList , w której dane są przechowywane w tablicy. Z resztą kolekcji zapoznamy się później. Teraz wystarczy zrozumieć, że klasa Collections jest zaprojektowana do pracy nie tylko z ArrayList, ale także z innymi typami kolekcji w Javie (stąd właściwie jej nazwa). Jakie zatem zadania pozwala rozwiązać klasa Collections podczas pracy z ArrayList? Pierwszym i najbardziej oczywistym jest sortowanie. W wykładzie o tablicach przyjrzeliśmy się przykładowi z liczbami, a teraz spójrzmy na przykład z ciągami znaków. Aby posortować zawartość kolekcji, klasa Collections implementuje następującą metodę sort():

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Rtęć");
       String venus = new String("Wenus");
       String earth = new String("Ziemia");
       String mars = new String("Mars");
       String jupiter = new String("Jowisz");
       String saturn = new String("Saturn");
       String uranus = new String(„Uran”);
       String neptune = new String("Neptun");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       System.out.println(solarSystem);

   }
}

Wniosek:

[Венера, Земля, Марс, Меркурий, Нептун, Сатурн, Уран, Юпитер]

Linie zostały posortowane alfabetycznie! Dlaczego w kolejności alfabetycznej? Klasa Stringjest zaprogramowana tak, aby dokładnie określić, w jaki sposób ciągi znaków są ze sobą porównywane (dokładnie alfabetycznie). Dla zajęć, które sam stworzysz, możesz zaimplementować własny mechanizm porównawczy, ale o tym porozmawiamy w innych wykładach. Dodatkowo klasa Collections umożliwia znalezienie minimalnego i maksymalnego elementu 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));

}

Wniosek:

7
1

Jest to oczywiście znacznie wygodniejsze niż ręczne pisanie kodu w celu przejrzenia wszystkich elementów i wyszukania największego/najmniejszego elementu :) Inną niezwykle przydatną metodą jest reverse(). Gdybyśmy musieli „odwrócić” listę, tak aby elementy były w odwrotnej kolejności, jak byśmy to zrobili? Samo napisanie takiego algorytmu pewnie nie byłoby takie proste :) Na szczęście metoda reverse()już wie jak to zrobić. Na przykład nie podoba nam się sposób, w jaki ta metoda sort()posortowała nasze planety w kolejności alfabetycznej i chcemy zmienić kolejność na odwrotną - z Z na A:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Rtęć");
       String venus = new String("Wenus");
       String earth = new String("Ziemia");
       String mars = new String("Mars");
       String jupiter = new String("Jowisz");
       String saturn = new String("Saturn");
       String uranus = new String(„Uran”);
       String neptune = new String("Neptun");

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

   }
}

Wniosek:

[Юпитер, Уран, Сатурн, Нептун, Меркурий, Марс, Земля, Венера]

Nawiasem mówiąc, często mówimy tutaj o sortowaniu, kolejności elementów itp. A co jeśli nasze zadanie jest dokładnie odwrotne? Na przykład staramy się wdrożyć mechanizm loterii. Do szpuli dodaliśmy 100 liczb, które powinny pojawiać się na ekranie pojedynczo. Wygrywa ten, kto jako pierwszy skreśli wszystkie cyfry na swoim bilecie. Bardzo łatwo jest zaimplementować taki mechanizm metodą shuffle():

public class Main {

   public static void main(java.lang.String[] args) {

       ArrayList<Integer> lottery = new ArrayList<>(100);
       for (int i = 1; i <= 100; i++) {

           lottery.add(i);//dodaj liczby od 1 do 100 do bębna
       }

       Collections.shuffle(lottery);//mieszać
       System.out.println("Uwaga! Pierwsze 10 numerów pojawia się z bębna!");
       for (int i = 0; i < 10; i++) {

           System.out.println(lottery.get(i));
       }

   }
}

Wniosek:

Внимание! Из барабана появляются первые 10 чисел!
32
61
4
81
25
8
66
35
42
71

To takie proste! Problem rozwiązany i nasz fragment gry napisany :) Wyobraźmy sobie teraz inną sytuację. Wcześniej stworzyliśmy listę solarSystemzawierającą wymienione planety. I wydaje się, że pasuje nam wszystkim, gdyby nie jedno: możesz usuwać z niego elementy i dodawać nowe! Zdecydowanie nie jest to zachowanie, jakiego oczekujemy: Układ Słoneczny w naszym programie powinien pozostać w niezmienionym stanie. Klasa Collections ma bardzo interesującą metodę - unmodifiableList(). Tworzy niezmienną wersję danej listy. Nie będzie można do niego dodać ani usunąć elementu. W przypadku listy planet Układu Słonecznego właśnie tego potrzebujemy!

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Rtęć");
       String venus = new String("Wenus");
       String earth = new String("Ziemia");
       String mars = new String("Mars");
       String jupiter = new String("Jowisz");
       String saturn = new String("Saturn");
       String uranus = new String(„Uran”);
       String neptune = new String("Neptun");

       List<String> solarSystem = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune)));
       solarSystem.add("Pluton");//spróbuj dodać nowy element
   }
}

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.Collections$UnmodifiableCollection.add(Collections.java:1075)
	at Main.main(Main.java:21)

Błąd: solarSystemTeraz nie możesz nic dodać! Jedyne na co trzeba w tym przypadku zwrócić uwagę to to, że typ zmiennej musi być List<>, a nie ArrayList<>(ta metoda zwraca obiekt dokładnie tego typu, wspólny dla wszystkich typów list). Inną częstą sytuacją, która może się zdarzyć podczas pracy, jest to, że programista dodał elementy w niewłaściwej kolejności. Jeśli tak się stało, a Merkury i Neptun nieoczekiwanie zamieniły się miejscami, poniższa metoda pomoże nam naprawić ten błąd swap():

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Rtęć");
       String venus = new String("Wenus");
       String earth = new String("Ziemia");
       String mars = new String("Mars");
       String jupiter = new String("Jowisz");
       String saturn = new String("Saturn");
       String uranus = new String(„Uran”);
       String neptune = new String("Neptun");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(neptune, venus, earth, mars
       , jupiter, saturn, uranus, mercury));// zła kolejność planet
       System.out.println(solarSystem);

       Collections.swap(solarSystem, solarSystem.indexOf(mercury), solarSystem.indexOf(neptune));
       System.out.println(solarSystem);

   }
}

Do metody przekazaliśmy naszą listę swap()wraz z indeksami dwóch elementów, które należy zamienić. Uwaga: metoda działa w szczególności z indeksami, a nie z linkami. Dlatego tutaj potrzebowaliśmy metody ArrayList.indexOf(). Wniosek:

[Нептун, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Меркурий]

[Меркурий, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Нептун]

Na koniec zapoznajmy się z bardzo interesującą metodą - disjoint(). Sprawdza, czy dwie kolekcje mają przecięcia, czyli przynajmniej jeden identyczny element. Jeśli nie, zwraca true, jeśli tak, zwraca false.

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Rtęć");
       String venus = new String("Wenus");
       String earth = new String("Ziemia");
       String mars = new String("Mars");
       String jupiter = new String("Jowisz");
       String saturn = new String("Saturn");
       String uranus = new String(„Uran”);
       String neptune = new String("Neptun");

       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ć, elementy na naszych dwóch listach są zupełnie różne, więc program wyświetli wynik true. To bardzo ciekawe i bardzo przydatne zajęcia. Na przykład Arrayswykonuje dla nas wiele rutynowych, niewdzięcznych prac, dzięki czemu możemy skupić się na innych rzeczach. Przeczytaj o tym w dokumentacji Oracle , są tam inne metody.