Java Academy · Lekcja

Interfejs Comparable

Implementuj Comparable, aby nadać klasie naturalny porządek, i używaj go z Collections.sort.

Interfejs Comparable to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 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.

Interfejs Comparable

Comparable<T> nadaje klasie naturalny porządek. Należy go zaimplementować, aby instancje można było sortować za pomocą Collections.sort(), Arrays.sort() oraz w posortowanych kolekcjach, takich jak TreeSet.

Implementowanie Comparable

Należy zaimplementować compareTo(T other), zwracając wartość ujemną (this < other), zero (równość) lub wartość dodatnią (this > other).

class Product implements Comparable<Product> {
    private final String name;
    private final double price;

    Product(String name, double price) {
        this.name = name; this.price = price;
    }

    @Override
    public int compareTo(Product other) {
        return Double.compare(this.price, other.price); // ascending by price
    }

    @Override public String toString() { return name + "($" + price + ")"; }
}

List<Product> products = new ArrayList<>(List.of(
    new Product("Mouse", 29.99),
    new Product("Laptop", 999.0),
    new Product("Keyboard", 79.99)
));
Collections.sort(products);
System.out.println(products); // [Mouse($29.99), Keyboard($79.99), Laptop($999.0)]

Kontrakt compareTo

Poprawna implementacja Comparable wymaga spełnienia określonego kontraktu:

Antysymetria: sgn(a.compareTo(b)) == -sgn(b.compareTo(a))
Przechodniość: jeśli a > b i b > c, to a > c
Spójność: a.compareTo(b) == 0 oznacza, że a.equals(b) jest zdecydowanie zalecane

Bezpieczne porównywanie typów prymitywnych

W metodzie compareTo nigdy nie należy odejmować wartości prymitywnych — przepełnienie liczby całkowitej może prowadzić do nieprawidłowych wyników. Należy używać Integer.compare(), Double.compare() itp.

// WRONG: integer subtraction can overflow
int compareTo(Player other) {
    return this.score - other.score; // overflow if scores differ by > Integer.MAX_VALUE
}

// CORRECT: use Integer.compare
int compareTo(Player other) {
    return Integer.compare(this.score, other.score);
}

// For strings: delegate to String.compareTo
int compareTo(Player other) {
    return this.name.compareTo(other.name); // String handles it correctly
}

Naturalny porządek w TreeSet

Klasy implementujące Comparable są automatycznie umieszczane we właściwym miejscu w posortowanych kolekcjach, takich jak TreeSet i TreeMap.

class Priority implements Comparable<Priority> {
    enum Level { LOW, MEDIUM, HIGH, CRITICAL }
    final Level level;
    final String task;
    Priority(Level level, String task) { this.level = level; this.task = task; }
    @Override
    public int compareTo(Priority other) {
        return this.level.compareTo(other.level); // enum ordinal order
    }
    @Override public String toString() { return level + ": " + task; }
}

TreeSet<Priority> queue = new TreeSet<>();
queue.add(new Priority(Priority.Level.CRITICAL, "Fix prod crash"));
queue.add(new Priority(Priority.Level.LOW, "Update docs"));
queue.add(new Priority(Priority.Level.HIGH, "Deploy feature"));
queue.forEach(System.out::println);
// LOW: Update docs
// HIGH: Deploy feature
// CRITICAL: Fix prod crash

Comparable dla wielu pól

Aby sortować według wielu pól, należy łączyć porównania: najpierw według głównego pola, a następnie według pomocniczego, jeśli wartości głównego pola są równe.

class Employee implements Comparable<Employee> {
    final String dept, name;
    final double salary;

    Employee(String dept, String name, double salary) {
        this.dept = dept; this.name = name; this.salary = salary;
    }

    @Override
    public int compareTo(Employee other) {
        int deptCmp = this.dept.compareTo(other.dept);
        if (deptCmp != 0) return deptCmp;           // primary: by dept
        return this.name.compareTo(other.name);      // secondary: by name
    }
}

Spójność Comparable i equals

Zdecydowanie zaleca się, choć nie jest to wymagane, aby a.compareTo(b) == 0 wtedy i tylko wtedy, gdy a.equals(b). Naruszenie tej zasady powoduje trudne do wykrycia błędy w posortowanych zbiorach i mapach.

// BigDecimal violates this: new BigDecimal("2.0").compareTo(new BigDecimal("2.00")) == 0
// but new BigDecimal("2.0").equals(new BigDecimal("2.00")) == false

// This causes TreeSet to treat them as equal (only one stored)
TreeSet<java.math.BigDecimal> set = new TreeSet<>();
set.add(new java.math.BigDecimal("2.0"));
set.add(new java.math.BigDecimal("2.00"));
System.out.println(set.size()); // 1 — compareTo-equal → same element

Sortowanie za pomocą Collections.sort

Collections.sort() i Arrays.sort() używają naturalnego porządku zdefiniowanego przez Comparable.

List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));
Collections.sort(names); // natural alphabetical order
System.out.println(names); // [Alice, Bob, Charlie]

String[] arr = {"banana", "apple", "cherry"};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [apple, banana, cherry]

// Stream sorted() uses natural order
names.stream().sorted().forEach(System.out::println);

Comparable w wyszukiwaniu binarnym

Collections.binarySearch() wymaga, aby lista była posortowana według naturalnego porządku, a jej elementy implementowały Comparable.

List<Integer> sorted = new ArrayList<>(List.of(1, 3, 5, 7, 9, 11));
int idx = Collections.binarySearch(sorted, 7);
System.out.println("Found 7 at index: " + idx); // 3

int missing = Collections.binarySearch(sorted, 4);
System.out.println("4 not found, insertion point: " + (-missing - 1)); // 2

Comparable a Comparator

Najważniejsze rozróżnienie:

Comparable: definiuje własny naturalny porządek klasy — jeden na klasę
Comparator: definiuje zewnętrzny porządek — dowolną liczbę komparatorów, które można łączyć

Praktyczny przykład: tabela wyników

Tabela wyników wykorzystująca Comparable do zdefiniowania naturalnego porządku malejącego według wyniku.

class LeaderboardEntry implements Comparable<LeaderboardEntry> {
    final String player;
    final int score;
    final long timestamp;

    LeaderboardEntry(String player, int score) {
        this.player = player; this.score = score;
        this.timestamp = System.nanoTime();
    }

    @Override
    public int compareTo(LeaderboardEntry other) {
        int scoreCmp = Integer.compare(other.score, this.score); // descending
        if (scoreCmp != 0) return scoreCmp;
        return Long.compare(this.timestamp, other.timestamp); // earlier = higher
    }

    @Override public String toString() { return player + ": " + score; }
}

TreeSet<LeaderboardEntry> board = new TreeSet<>();
board.add(new LeaderboardEntry("Alice", 950));
board.add(new LeaderboardEntry("Bob", 1200));
board.add(new LeaderboardEntry("Carol", 950));
board.forEach(System.out::println);
// Bob: 1200 / Alice: 950 / Carol: 950

Szybkie sprawdzenie

Co zwraca compareTo(), gdy bieżący obiekt jest mniejszy od argumentu?

Podsumowanie: interfejs Comparable

Najważniejsze informacje:

Należy zaimplementować Comparable, aby zdefiniować naturalny porządek klasy
compareTo zwraca wartość ujemną (mniejszy), zero (równy) lub dodatnią (większy)
Należy używać Integer.compare()/Double.compare() — nigdy odejmowania (ryzyko przepełnienia)
W przypadku sortowania według wielu pól należy łączyć porównania: główne → pomocnicze
Naturalny porządek jest używany przez Collections.sort, Arrays.sort, TreeSet i TreeMap
Comparable definiuje JEDEN porządek; w przypadku wielu porządków należy użyć Comparator

Często zadawane pytania

Czy lekcja „Interfejs Comparable” jest bezpłatna?

Tak — pełny tekst „Interfejs Comparable” 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 „Interfejs Comparable”?

Implementuj Comparable, aby nadać klasie naturalny porządek, i używaj go z Collections.sort. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Interfejs Comparable”?

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