Lära Comparable: Naturlig Ordning av Data | Grunder och Funktionella Möjligheter med Stream API

I Java är det vanligt att behöva sortera objekt. Till exempel, i en lista med böcker kan du vilja sortera dem efter titel, författare eller utgivningsår.

För att hantera sådana uppgifter tillhandahåller Java gränssnitten Comparable och Comparator. Båda uppnår samma mål (sortering av objekt) men gör det på olika sätt. Låt oss gå igenom dem en i taget.

Vad är Comparable?

Till exempel sorteras Java-strängar alfabetiskt som standard eftersom klassen String implementerar Comparable.

Den viktiga metoden i det funktionella gränssnittet Comparable är:

int compareTo(T o);

Denna metod returnerar:

Ett negativt tal om det aktuella objektet är mindre än det angivna objektet;
Noll om objekten är lika;
Ett positivt tal om det aktuella objektet är större än det angivna objektet.

Exempel: Sortera böcker efter år

Anta att du vill jämföra Book-objekt baserat på deras utgivningsår.

För att uppnå detta kan klassen Book implementera Comparable och överskrida metoden compareTo. Genom att överskrida denna metod definierar du hur Book-objekt ska jämföras, vilket direkt påverkar sorteringsbeteendet i metoder som Collections.sort().

Detta gör det möjligt att styra ordningen i vilken böcker sorteras—antingen stigande eller fallande—baserat på den logik du implementerar i compareTo.

Main.java


              1234567891011121314151617181920212223242526272829303132333435363738394041424344
            
package com.example;

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        List<Book> books = new ArrayList<>();
        books.add(new Book("Book A", "Author X", 2020));
        books.add(new Book("Book B", "Author Y", 2018));
        books.add(new Book("Book C", "Author Z", 2021));

        Collections.sort(books); // Uses `compareTo`

        System.out.println(books);
    }
}

class Book implements Comparable<Book> {
    private String title;
    private String author;
    private int year;

    public Book(String title, String author, int year) {
        this.title = title;
        this.author = author;
        this.year = year;
    }

    public int getYear() {
        return year;
    }

    @Override
    public int compareTo(Book other) {
        return Integer.compare(this.year, other.year); // Compare by publication year
    }

    @Override
    public String toString() {
        return title + " (" + year + ")";
    }
}

När Collections.sort(books) anropas, itererar Java genom listan och jämför elementen med hjälp av metoden compareTo som definierats i klassen Book.

Vid varje jämförelse returnerar compareTo ett numeriskt värde som avgör ordningen mellan två böcker. Baserat på dessa värden omorganiserar sorteringsalgoritmen elementen så att de ordnas efter stigande utgivningsår.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 8

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Suggested prompts:

Can you show an example of how to implement Comparable in a Book class?

What happens if two books have the same publication year?

How does Comparable differ from Comparator?

Awesome!

Completion rate improved to 2.33

Svep för att visa menyn