Java Academy · Lektion

Gränssnittet Comparable

Implementera Comparable för att ge en klass en naturlig ordning och använda den med Collections.sort.

Lektion 1 av 413 steg

Gränssnittet Comparable är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Gränssnittet Comparable

Comparable<T> ger en klass en naturlig ordning. Implementera det för att göra instanser sorterbara med Collections.sort(), Arrays.sort() och sorterade samlingar som TreeSet.

Implementera Comparable

Implementera compareTo(T other) så att metoden returnerar ett negativt värde (this < other), noll (lika) eller ett positivt värde (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)]

Kontraktet för compareTo

För att implementera Comparable korrekt måste ett kontrakt uppfyllas:

Antisymmetri: sgn(a.compareTo(b)) == -sgn(b.compareTo(a))
Transitivitet: om a > b och b > c, så är a > c
Konsistens: a.compareTo(b) == 0 innebär att a.equals(b) starkt rekommenderas

Jämföra primitiva typer säkert

Subtrahera aldrig primitiva värden i compareTo – heltalsöverflöde kan ge felaktiga resultat. Använd Integer.compare(), Double.compare() och liknande i stället.

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

Naturlig ordning i TreeSet

Klasser som implementerar Comparable placeras automatiskt i sorterade samlingar som TreeSet och 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 med flera fält

Om ni vill sortera efter flera fält kedjar ni jämförelser: primärt fält, sedan sekundärt om det primära är lika.

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

Konsistens mellan Comparable och equals

Det rekommenderas starkt, men krävs inte, att a.compareTo(b) == 0 om och endast om a.equals(b). Om detta bryts uppstår subtila fel i sorterade mängder och mappar.

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

Sortera med Collections.sort

Collections.sort() och Arrays.sort() använder den naturliga ordning som definieras av 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 i binärsökning

Collections.binarySearch() kräver att listan är sorterad enligt den naturliga ordningen och att elementen implementerar 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 kontra Comparator

Viktig skillnad:

Comparable: definierar klassens egen naturliga ordning – en per klass
Comparator: definierar en extern ordning – obegränsat många och möjliga att komponera

Praktiskt exempel: resultatlista

En resultatlista som använder Comparable för en naturlig ordning med poängen i fallande ordning.

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

Snabbkontroll

Vad returnerar compareTo() när det aktuella objektet är mindre än argumentet?

Besvara frågan i den interaktiva lektionen

Sammanfattning: gränssnittet Comparable

Viktiga punkter:

Implementera Comparable<T> för att definiera klassens naturliga ordning
compareTo returnerar negativt (mindre), noll (lika) eller positivt (större)
Använd Integer.compare()/Double.compare() – subtrahera aldrig (risk för överflöde)
Kedja jämförelser vid sortering efter flera fält: primärt → sekundärt
Den naturliga ordningen används av Collections.sort, Arrays.sort, TreeSet och TreeMap
Comparable definierar EN ordning; använd Comparator för flera ordningar

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Gränssnittet Comparable” gratis?

Ja – hela texten till ”Gränssnittet Comparable” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Gränssnittet Comparable”?

Implementera Comparable för att ge en klass en naturlig ordning och använda den med Collections.sort. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Gränssnittet Comparable”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Gränssnittet Comparable
Comparator och sortering med lambda-uttryck
Sortering med flera nycklar och thenComparing
Sortera arrayer och samlingar i praktiken

← Tillbaka till Java Academy