Java Academy · Lekcja

TreeSet i NavigableSet

Przechowuj unikalne, posortowane elementy i używaj floor, ceiling, higher oraz lower do wyszukiwania najbliższych sąsiadów.

TreeSet i NavigableSet to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Czym jest TreeSet?

TreeSet to posortowany zbiór oparty na drzewie czerwono-czarnym. Przechowuje unikalne elementy w rosnącej kolejności naturalnej (lub w kolejności określonej przez przekazany komparator). Wszystkie operacje mają złożoność O(log n).

import java.util.TreeSet;

TreeSet<String> names = new TreeSet<>();
names.add("Charlie");
names.add("Alice");
names.add("Bob");
names.add("Alice"); // duplicate ignored

for (String s : names) System.out.print(s + " ");
// Alice Bob Charlie

Metody NavigableSet: floor, ceiling, lower, higher

TreeSet implementuje interfejs NavigableSet, udostępniając metody nawigacyjne do znajdowania najbliższych elementów:

TreeSet<Integer> set = new TreeSet<>();
for (int i = 10; i <= 50; i += 10) set.add(i);
// {10, 20, 30, 40, 50}

System.out.println(set.floor(25));   // 20 (greatest ≤ 25)
System.out.println(set.ceiling(25)); // 30 (smallest ≥ 25)
System.out.println(set.lower(30));   // 20 (strictly less)
System.out.println(set.higher(30));  // 40 (strictly greater)

first, last, pollFirst, pollLast

Uzyskaj dostęp do elementów granicznych lub usuń je:

TreeSet<String> ts = new TreeSet<>(Set.of("cherry","apple","banana","date"));

System.out.println(ts.first());       // apple
System.out.println(ts.last());        // date
System.out.println(ts.pollFirst());   // apple (removed)
System.out.println(ts.pollLast());    // date (removed)
System.out.println(ts);              // [banana, cherry]

headSet, tailSet, subSet

Wyodrębnij widoki posortowanych podzbiorów:

TreeSet<Integer> set = new TreeSet<>(Set.of(1,2,3,4,5,6,7,8,9,10));

System.out.println(set.headSet(5));      // [1, 2, 3, 4]
System.out.println(set.tailSet(7));      // [7, 8, 9, 10]
System.out.println(set.subSet(3, 7));    // [3, 4, 5, 6]

// Inclusive upper bound:
System.out.println(set.subSet(3, true, 7, true)); // [3,4,5,6,7]

Iterowanie malejące

Użyj descendingIterator() lub descendingSet(), aby uzyskać odwrotną kolejność:

TreeSet<Integer> ts = new TreeSet<>(Set.of(1,3,5,7,9));

// Descending iterator
var it = ts.descendingIterator();
while (it.hasNext()) System.out.print(it.next() + " ");
// 9 7 5 3 1

Własne sortowanie za pomocą Comparator

Przekaż Comparator, aby sortować w kolejności innej niż naturalna — na przykład od najdłuższego napisu:

TreeSet<String> byLength = new TreeSet<>(
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder())
);
byLength.add("Hi");
byLength.add("Hello");
byLength.add("Hey");
byLength.add("Java");

for (String s : byLength) System.out.print(s + " ");
// Hi Hey Java Hello

Przypadek użycia: posortowane unikalne nazwy użytkowników

Przechowuj nazwy użytkowników w TreeSet, aby automatycznie usuwać duplikaty i zachować kolejność alfabetyczną:

TreeSet<String> users = new TreeSet<>();
users.add("alice");
users.add("bob");
users.add("alice"); // ignored
users.add("carol");

System.out.println(users.first()); // alice
System.out.println(users);         // [alice, bob, carol]

Przypadek użycia: zliczanie w zakresie

Policz elementy w zakresie, używając subSet:

TreeSet<Integer> scores = new TreeSet<>();
for (int s : new int[]{45,62,78,55,90,88,34,71}) scores.add(s);

// Scores between 60 and 89 (inclusive)
int count = scores.subSet(60, true, 89, true).size();
System.out.println("Students in B range: " + count); // 3 (62, 78, 88... wait: 62,78,71,88=4)
// Actually: 62,71,78,88 = 4

TreeSet a HashSet i LinkedHashSet

Wybór zależy od potrzeb:

HashSet: operacje O(1), brak uporządkowania
LinkedHashSet: operacje O(1), kolejność wstawiania
TreeSet: operacje O(log n), kolejność sortowania, metody nawigacyjne

TreeSet wymaga, aby elementy implementowały Comparable lub aby użyć obiektu Comparator.

Elementy null

TreeSet NIE zezwala na elementy null przy użyciu kolejności naturalnej — zgłaszany jest NullPointerException, ponieważ wartości null nie można porównywać. Zadziała własny komparator, który jawnie obsługuje wartości null.

TreeSet<String> ts = new TreeSet<>();
try {
    ts.add(null); // throws NullPointerException
} catch (NullPointerException e) {
    System.out.println("Cannot add null: " + e);
}

Bezpieczeństwo wątkowe

TreeSet NIE jest bezpieczna wątkowo. Należy zewnętrznie synchronizować ją za pomocą Collections.synchronizedSortedSet() albo użyć ConcurrentSkipListSet, który jest jednocześnie posortowany i bezpieczny wątkowo.

Szybkie sprawdzenie

Obiekt TreeSet<Integer> zawiera {10, 20, 30, 40, 50}. Co zwraca set.ceiling(35)?

Podsumowanie: TreeSet i NavigableSet

Najważniejsze informacje:

TreeSet przechowuje unikalne posortowane elementy (O(log n))
Implementuje NavigableSet: floor, ceiling, lower, higher, first, last
headSet, tailSet i subSet zwracają powiązane widoki zakresów
Użyj descendingSet()/descendingIterator() dla odwrotnej kolejności
Nie jest bezpieczny wątkowo — w przypadku współbieżności użyj ConcurrentSkipListSet

Często zadawane pytania

Czy lekcja „TreeSet i NavigableSet” jest bezpłatna?

Tak — pełny tekst „TreeSet i NavigableSet” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „TreeSet i NavigableSet”?

Przechowuj unikalne, posortowane elementy i używaj floor, ceiling, higher oraz lower do wyszukiwania najbliższych sąsiadów. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „TreeSet i NavigableSet”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy