Lære Komparator: Egendefinert Sammenligning av Data | Grunnleggende og Funksjonelle Egenskaper ved Stream API

La oss se på det andre funksjonelle grensesnittet, Comparator, undersøke hvordan det implementerer sammenligning, og forstå forskjellen mellom Comparator og Comparable.

Hva er Comparator?

Den viktige metoden i det funksjonelle grensesnittet Comparator er:

int compare(T o1, T o2);

Metoden compare(T o1, T o2) returnerer:

Et negativt tall hvis o1 er mindre enn o2;
Null hvis o1 og o2 er like;
Et positivt tall hvis o1 er større enn o2.

Praktisk bruk

Her implementeres sortering av Book-objekter ved bruk av Comparator-grensesnittet. I stedet for å implementere sammenligningsmetoden i selve Book-klassen, brukes statisk metoder fra Comparator-grensesnittet for å definere sorteringslogikken.

Main.java


              1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253
            
package com.example;

import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        List<Book> books = new ArrayList<>();
        books.add(new Book("The Great Gatsby", "F. Scott Fitzgerald", 1925));
        books.add(new Book("To Kill a Mockingbird", "Harper Lee", 1960));
        books.add(new Book("1984", "George Orwell", 1949));
  
        // Sort by title
        books.sort(Comparator.comparing(Book::getTitle));
        System.out.println("Sorted by title: " + books);
        
        System.out.println("------------------------");

        // Sort by author
        books.sort(Comparator.comparing(Book::getAuthor));
        System.out.println("Sorted by author: " + books);
    }
}

class 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 String getTitle() {
       return title;
    }

    public String getAuthor() {
       return author;
    }

    public int getYear() {
       return year;
    }

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

I dette eksemplet bruker du Comparator-grensesnittet for å sortere listen books. Men hvorfor brukte du metoden comparing() i stedet for compare()?

Hvis du ønsker å bruke metoden compare(), må du opprette et Comparator-objekt og implementere compare-metoden.

public static Comparator<Book> titleComparator = new Comparator<Book>() {
    @Override
    public int compare(Book b1, Book b2) {
        return b1.getTitle().compareTo(b2.getTitle());
    }
};

Denne koden definerer en Comparator<Book> ved bruk av en anonym klasse for å sammenligne to Book-objekter basert på deres title.

Siden String implementerer Comparable, brukes metoden compareTo() for å sammenligne titlene leksikografisk, og returnerer en negativ, null eller positiv verdi.

Alternativt kan du oppnå samme resultat med et lambda-uttrykk for en mer konsis implementering:

(b1, b2) -> b1.getTitle().compareTo(b2.getTitle());

Men det finnes en enda enklere tilnærming: bruk av Comparator.comparing()-metoden. Denne metoden håndterer automatisk sammenligningslogikken for deg, noe som gjør koden mer lesbar og kortfattet.

Du sender ganske enkelt en metodereferanse som henter ut feltet for sammenligning.

Comparator.comparing(Book::getTitle)

sort()-metoden til listen kaller den overførte Comparator, som igjen bestemmer rekkefølgen på elementene ved å sammenligne dem basert på verdiene returnert av de angitte metodene.

Flersjikting

Hvis du trenger å sortere etter flere kriterier, kan du bruke thenComparing-metoden:

books.sort(
       Comparator.comparing(Book::getYear) // First by year
           .thenComparing(Book::getTitle) // Then by title
);

Dette eksempelet viser hvordan du kan sortere en liste med bøker først etter utgivelsesyear og deretter etter title. Sorteringsprosessen sammenligner først bøkene basert på year, og hvis to bøker har samme year, sammenlignes de etter title for å bestemme endelig rekkefølge.

Omvendt sortering

Omvending av sorteringsrekkefølgen i Java er nyttig når du må sortere elementer etter ett kriterium først og deretter endre rekkefølgen for neste kriterium.

Metodene reversed() og Comparator.reverseOrder() hjelper til med å kontrollere sorteringsretning, men de fungerer forskjellig.

books.sort(
    Comparator.comparing(Book::getYear).reversed() // Sort by year (descending)
        .thenComparing(Book::getTitle, Comparator.reverseOrder()) // Then by title (descending)
);

Bøkene sorteres først etter utgivelsesår (year) i synkende rekkefølge ved bruk av reversed(). Dersom flere bøker har samme year, benytter thenComparing() sortering etter title i omvendt alfabetisk rekkefølge med Comparator.reverseOrder().

Dette sikrer at de nyeste bøkene vises først, og innenfor samme year sorteres titles fra Z til A.

Forskjeller mellom Comparable og Comparator

Bruk Comparable-grensesnittet når en klasse har en naturlig sorteringsrekkefølge, for eksempel sortering etter ett enkelt felt. Bruk Comparator når du skal sortere etter flere kriterier eller når du må definere en egendefinert rekkefølge for objekter.

1. Når bør man bruke `Comparable`-grensesnittet?

2. Når bør man bruke `Comparator`-grensesnittet?

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 9

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Suggested prompts:

Can you explain the main differences between Comparator and Comparable?

How do I choose between using Comparator and Comparable in my code?

Can you show an example of sorting with Comparable?

Awesome!

Completion rate improved to 2.33

Sveip for å vise menyen

La oss se på det andre funksjonelle grensesnittet, Comparator, undersøke hvordan det implementerer sammenligning, og forstå forskjellen mellom Comparator og Comparable.

Hva er Comparator?

Den viktige metoden i det funksjonelle grensesnittet Comparator er:

int compare(T o1, T o2);

Metoden compare(T o1, T o2) returnerer:

Et negativt tall hvis o1 er mindre enn o2;
Null hvis o1 og o2 er like;
Et positivt tall hvis o1 er større enn o2.

Praktisk bruk

Main.java


              1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253
            
package com.example;

import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        List<Book> books = new ArrayList<>();
        books.add(new Book("The Great Gatsby", "F. Scott Fitzgerald", 1925));
        books.add(new Book("To Kill a Mockingbird", "Harper Lee", 1960));
        books.add(new Book("1984", "George Orwell", 1949));
  
        // Sort by title
        books.sort(Comparator.comparing(Book::getTitle));
        System.out.println("Sorted by title: " + books);
        
        System.out.println("------------------------");

        // Sort by author
        books.sort(Comparator.comparing(Book::getAuthor));
        System.out.println("Sorted by author: " + books);
    }
}

class 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 String getTitle() {
       return title;
    }

    public String getAuthor() {
       return author;
    }

    public int getYear() {
       return year;
    }

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

I dette eksemplet bruker du Comparator-grensesnittet for å sortere listen books. Men hvorfor brukte du metoden comparing() i stedet for compare()?

Hvis du ønsker å bruke metoden compare(), må du opprette et Comparator-objekt og implementere compare-metoden.

public static Comparator<Book> titleComparator = new Comparator<Book>() {
    @Override
    public int compare(Book b1, Book b2) {
        return b1.getTitle().compareTo(b2.getTitle());
    }
};

Denne koden definerer en Comparator<Book> ved bruk av en anonym klasse for å sammenligne to Book-objekter basert på deres title.

Siden String implementerer Comparable, brukes metoden compareTo() for å sammenligne titlene leksikografisk, og returnerer en negativ, null eller positiv verdi.

Alternativt kan du oppnå samme resultat med et lambda-uttrykk for en mer konsis implementering:

(b1, b2) -> b1.getTitle().compareTo(b2.getTitle());

Du sender ganske enkelt en metodereferanse som henter ut feltet for sammenligning.

Comparator.comparing(Book::getTitle)

Flersjikting

Hvis du trenger å sortere etter flere kriterier, kan du bruke thenComparing-metoden:

books.sort(
       Comparator.comparing(Book::getYear) // First by year
           .thenComparing(Book::getTitle) // Then by title
);

Omvendt sortering

Omvending av sorteringsrekkefølgen i Java er nyttig når du må sortere elementer etter ett kriterium først og deretter endre rekkefølgen for neste kriterium.

Metodene reversed() og Comparator.reverseOrder() hjelper til med å kontrollere sorteringsretning, men de fungerer forskjellig.

books.sort(
    Comparator.comparing(Book::getYear).reversed() // Sort by year (descending)
        .thenComparing(Book::getTitle, Comparator.reverseOrder()) // Then by title (descending)
);

Dette sikrer at de nyeste bøkene vises først, og innenfor samme year sorteres titles fra Z til A.

Forskjeller mellom Comparable og Comparator

1. Når bør man bruke `Comparable`-grensesnittet?

2. Når bør man bruke `Comparator`-grensesnittet?

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 1. Kapittel 9

Komparator: Egendefinert Sammenligning av Data

Hva er Comparator?

Praktisk bruk

Flersjikting

Omvendt sortering

Forskjeller mellom Comparable og Comparator

1. Når bør man bruke Comparable-grensesnittet?

2. Når bør man bruke Comparator-grensesnittet?

Awesome!

Komparator: Egendefinert Sammenligning av Data

Hva er Comparator?

Praktisk bruk

Flersjikting

Omvendt sortering

Forskjeller mellom Comparable og Comparator

1. Når bør man bruke Comparable-grensesnittet?

2. Når bør man bruke Comparator-grensesnittet?

1. Når bør man bruke `Comparable`-grensesnittet?

2. Når bør man bruke `Comparator`-grensesnittet?

1. Når bør man bruke `Comparable`-grensesnittet?

2. Når bør man bruke `Comparator`-grensesnittet?