Java Academy · Lekcja

Sortowanie tablic i kolekcji w praktyce

Stosuj sortowanie do list produktów, rankingów i harmonogramów wydarzeń, korzystając z rzeczywistych przykładów.

Lekcja 4 z 414 kroki

Sortowanie tablic i kolekcji w praktyce to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 4 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.

Sortowanie w praktyce

Ta lekcja pokazuje zastosowanie technik sortowania w realistycznych scenariuszach: katalogach produktów, rankingach, planowaniu wydarzeń i ustalaniu kolejności wyników wyszukiwania.

Arrays.sort dla tablic typów prostych

W przypadku tablic typów prostych Arrays.sort() używa algorytmu quicksort z dwoma pivotami — niezwykle szybkiego, o średniej złożoności O(n log n).

int[] scores = {45, 90, 78, 62, 88, 33};
Arrays.sort(scores);
System.out.println(Arrays.toString(scores)); // [33, 45, 62, 78, 88, 90]

// Sort a range only
int[] data = {9, 3, 7, 1, 5};
Arrays.sort(data, 1, 4); // sort indices 1-3 only
System.out.println(Arrays.toString(data)); // [9, 1, 3, 7, 5]

Arrays.sort dla tablic obiektów

W przypadku tablic obiektów Arrays.sort() używa algorytmu TimSort (stabilnego). Można przekazać Comparator, aby zdefiniować niestandardowe uporządkowanie.

String[] names = {"Charlie", "Alice", "Bob", "Diana"};
Arrays.sort(names);
System.out.println(Arrays.toString(names)); // [Alice, Bob, Charlie, Diana]

// Custom order: by length, then alphabetically
Arrays.sort(names, Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));
System.out.println(Arrays.toString(names)); // [Bob, Alice, Diana, Charlie]

Collections.sort i List.sort

Obie metody sortują List w miejscu. List.sort() to obecnie preferowane rozwiązanie.

List<Integer> nums = new ArrayList<>(List.of(5, 2, 8, 1, 9, 3));

// Old way
Collections.sort(nums);
System.out.println(nums); // [1, 2, 3, 5, 8, 9]

// Modern way (same result)
nums.sort(Comparator.naturalOrder());
nums.sort(null); // null means natural order

// Descending
nums.sort(Comparator.reverseOrder());
System.out.println(nums); // [9, 8, 5, 3, 2, 1]

Stream.sorted() w stylu funkcyjnym

Użyj stream().sorted() podczas tworzenia potoku — powstaje nowy posortowany strumień bez modyfikowania źródła.

List<String> cities = List.of("Tokyo", "London", "New York", "Paris", "Sydney");

// Sorted stream — source list unchanged
List<String> sorted = cities.stream()
    .sorted(Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()))
    .collect(Collectors.toList());

System.out.println(sorted);
// [Paris, Tokyo, London, Sydney, New York]

Sortowanie Map według wartości

Klasyczne pytanie rekrutacyjne: sortowanie Map według wartości za pomocą strumienia i Comparator.

import java.util.*;
import java.util.stream.*;

Map<String, Integer> scores = Map.of(
    "Alice", 95, "Bob", 87, "Charlie", 92, "Diana", 87
);

Map<String, Integer> sorted = scores.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue(Comparator.reverseOrder())
        .thenComparing(Map.Entry.comparingByKey()))
    .collect(Collectors.toLinkedHashMap(
        Map.Entry::getKey, Map.Entry::getValue,
        (v1, v2) -> v1, LinkedHashMap::new));

sorted.forEach((k, v) -> System.out.println(k + ": " + v));
// Alice: 95 / Charlie: 92 / Bob: 87 / Diana: 87

Sortowanie za pomocą Collator z uwzględnieniem ustawień regionalnych

Do sortowania ciągów znaków z uwzględnieniem języka użyj java.text.Collator zamiast String.compareTo — obsługuje akcenty, wielkość liter i porządkowanie właściwe dla danych ustawień regionalnych.

import java.text.*;
import java.util.*;

List<String> names = new ArrayList<>(List.of("éclair", "apple", "Über", "banana"));

Collator collator = Collator.getInstance(Locale.GERMAN);
names.sort(collator);
System.out.println(names); // locale-aware sort

Sortowanie obiektów według wielu kryteriów

Sortowanie produktów w e-commerce: najpierw dostępne w magazynie, następnie według ceny promocyjnej, potem oceny, a na końcu nazwy.

record Product(String name, double price, double salePrice, double rating, boolean inStock) {}

Comparator<Product> bestFirst = Comparator
    .comparing(Product::inStock).reversed()           // in-stock first
    .thenComparingDouble(Product::salePrice)          // cheapest sale price
    .thenComparingDouble(Product::rating).reversed()  // highest rated
    .thenComparing(Product::name);                    // alphabetical tiebreak

Sortowanie wydarzeń według daty i godziny

Chronologiczne sortowanie harmonogramu wydarzeń za pomocą typów java.time, które implementują Comparable.

import java.time.*;
import java.util.*;

record Event(String title, LocalDate date, LocalTime time) {}

List<Event> schedule = new ArrayList<>(List.of(
    new Event("Workshop",  LocalDate.of(2024,7,15), LocalTime.of(9, 0)),
    new Event("Keynote",   LocalDate.of(2024,7,14), LocalTime.of(10, 30)),
    new Event("Lunch Talk",LocalDate.of(2024,7,15), LocalTime.of(12, 0)),
    new Event("Hackathon", LocalDate.of(2024,7,14), LocalTime.of(9, 0))
));

schedule.sort(Comparator.comparing(Event::date).thenComparing(Event::time));
schedule.forEach(e -> System.out.println(e.date() + " " + e.time() + " " + e.title()));

Elementy Top-N przez sortowanie

Efektywne znajdowanie elementów Top-N: sortuj malejąco i wybierz pierwsze N albo użyj PriorityQueue dla dużych zbiorów danych.

List<Integer> values = List.of(42, 17, 88, 5, 73, 56, 91, 33);

// Simple approach: sort descending, take first 3
List<Integer> top3 = values.stream()
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());
System.out.println(top3); // [91, 88, 73]

// For very large datasets: PriorityQueue min-heap approach is O(n log k)
import java.util.PriorityQueue;
PriorityQueue<Integer> heap = new PriorityQueue<>(3);
for (int v : values) {
    heap.offer(v);
    if (heap.size() > 3) heap.poll();
}
System.out.println(new TreeSet<>(heap).descendingSet()); // [73, 88, 91]

Usuwanie duplikatów przez sortowanie

Po sortowaniu duplikaty sąsiadują ze sobą — możliwe jest wykrywanie ich w czasie O(n).

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5};
Arrays.sort(arr); // sort first

// Remove duplicates in O(n) after sorting
int[] unique = Arrays.stream(arr).distinct().toArray();
System.out.println(Arrays.toString(unique)); // [1, 2, 3, 4, 5, 6, 9]

Wydajność: wybór metody sortowania

Wybór właściwego podejścia do sortowania:

Tablice typów prostych: Arrays.sort() — najszybszy quicksort wykonywany w miejscu
Tablice obiektów/listy z Comparable: Collections.sort() lub List.sort(null)
Wiele sposobów porządkowania: łańcuchy Comparator z thenComparing
Elementy Top-N z dużego strumienia: PriorityQueue lub Stream.sorted().limit(N)

Szybki test

Jakiego algorytmu sortowania Java używa dla tablic obiektów w Arrays.sort()?

Odpowiedz w interaktywnej lekcji

Podsumowanie: sortowanie tablic i kolekcji w praktyce

Najważniejsze informacje:

Arrays.sort() dla typów prostych używa quicksorta z dwoma pivotami, a dla obiektów algorytmu TimSort (stabilnego)
List.sort(comparator) i Collections.sort() używają stabilnego algorytmu TimSort
stream().sorted() tworzy nowy posortowany strumień bez modyfikowania źródła
Sortowanie Map według wartości: entrySet().stream().sorted(Map.Entry.comparingByValue())
Do sortowania ciągów znaków z uwzględnieniem ustawień regionalnych użyj Collator
W przypadku elementów Top-N z dużych zbiorów danych PriorityQueue o pojemności k jest wydajniejsza niż pełne sortowanie

Bezpłatny start

Ucz się Java dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 104
Lekcje: 374

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Sortowanie tablic i kolekcji w praktyce” jest bezpłatna?

Tak — pełny tekst „Sortowanie tablic i kolekcji w praktyce” 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 „Sortowanie tablic i kolekcji w praktyce”?

Stosuj sortowanie do list produktów, rankingów i harmonogramów wydarzeń, korzystając z rzeczywistych przykładó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 4 z 4.

Ile czasu zajmuje lekcja „Sortowanie tablic i kolekcji w praktyce”?

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

Interfejs Comparable
Comparator i sortowanie za pomocą lambd
Sortowanie według wielu kluczy za pomocą thenComparing
Sortowanie tablic i kolekcji w praktyce

← Powrót do Java Academy