Lære Comparator: Brugerdefineret Sammenligning af Data | Grundlæggende og Funktionelle Kapaciteter af Stream API

Lad os se på det andet funktionelle interface, Comparator, undersøge hvordan det implementerer sammenligning, og forstå forskellen mellem Comparator og Comparable.

Hvad er Comparator?

Den centrale metode i det funktionelle interface Comparator er:

int compare(T o1, T o2);

Metoden compare(T o1, T o2) returnerer:

Et negativt tal, hvis o1 er mindre end o2;
Nul, hvis o1 og o2 er lige;
Et positivt tal, hvis o1 er større end o2.

Praktisk anvendelse

Implementering af sortering af Book-objekter ved brug af Comparator-interface. I stedet for at implementere sammenligningsmetoden i selve Book-klassen, anvendes statisk metoder fra Comparator-interface til at 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 eksempel anvendes Comparator-interfacet til at sortere listen books. Men hvorfor bruges comparing()-metoden i stedet for compare()?

Hvis du ønsker at bruge compare()-metoden, skal du oprette 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 kode definerer en Comparator<Book> ved hjælp af en anonym klasse til at sammenligne to Book-objekter ud fra deres title.

Da String implementerer Comparable, anvendes compareTo()-metoden til at sammenligne titlerne leksikografisk, hvilket returnerer en negativ, nul eller positiv værdi.

Alternativt kan samme resultat opnås med et lambda-udtryk for en mere kortfattet implementering:

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

Men der findes en endnu enklere tilgang: brug af Comparator.comparing() metoden. Denne metode håndterer automatisk sammenligningslogikken for dig, hvilket gør det mere læsbart og kortfattet.

Du skal blot angive en metodereference, der udtrækker det felt, der skal sammenlignes.

Comparator.comparing(Book::getTitle)

sort() metoden på listen kalder den angivne Comparator, som derefter bestemmer rækkefølgen af elementerne ved at sammenligne dem baseret på de værdier, der returneres af de angivne metoder.

Flerstrenget sortering

Hvis der er behov for at sortere efter flere kriterier, kan metoden thenComparing anvendes:

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

Dette eksempel viser, hvordan en liste af bøger først kan sorteres efter deres udgivelsesyear og derefter efter title. Sorteringsprocessen sammenligner først bøgerne baseret på deres year, og hvis to bøger har samme year, sammenlignes de derefter efter title for at bestemme deres endelige rækkefølge.

Omvendt sortering

Omvendelse af sorteringsrækkefølgen i Java er nyttigt, når der skal sorteres elementer efter ét kriterium først og derefter ændres rækkefølgen for det næste kriterium.

Metoderne reversed() og Comparator.reverseOrder() hjælper med at styre sorteringsretningen, men de fungerer forskelligt.

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

Bøgerne sorteres først efter deres udgivelsesår (year) i faldende rækkefølge ved hjælp af reversed(). Hvis flere bøger har samme year, sorterer thenComparing() dem efter title i omvendt alfabetisk rækkefølge ved hjælp af Comparator.reverseOrder().

Dette sikrer, at de nyeste bøger vises først, og inden for samme år sorteres titlerne fra Z til A.

Forskelle mellem Comparable og Comparator

Brug Comparable-interfacet, når en klasse har en naturlig rækkefølge, såsom sortering efter et enkelt felt. Brug Comparator, når der skal sorteres efter flere kriterier, eller når du skal definere en brugerdefineret rækkefølge for objekter.

1. Hvornår skal `Comparable`-interfacet anvendes?

2. Hvornår skal `Comparator`-interfacet anvendes?

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 9

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

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

Stryg for at vise menuen

Lad os se på det andet funktionelle interface, Comparator, undersøge hvordan det implementerer sammenligning, og forstå forskellen mellem Comparator og Comparable.

Hvad er Comparator?

Den centrale metode i det funktionelle interface Comparator er:

int compare(T o1, T o2);

Metoden compare(T o1, T o2) returnerer:

Et negativt tal, hvis o1 er mindre end o2;
Nul, hvis o1 og o2 er lige;
Et positivt tal, hvis o1 er større end o2.

Praktisk anvendelse

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 eksempel anvendes Comparator-interfacet til at sortere listen books. Men hvorfor bruges comparing()-metoden i stedet for compare()?

Hvis du ønsker at bruge compare()-metoden, skal du oprette 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 kode definerer en Comparator<Book> ved hjælp af en anonym klasse til at sammenligne to Book-objekter ud fra deres title.

Da String implementerer Comparable, anvendes compareTo()-metoden til at sammenligne titlerne leksikografisk, hvilket returnerer en negativ, nul eller positiv værdi.

Alternativt kan samme resultat opnås med et lambda-udtryk for en mere kortfattet implementering:

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

Du skal blot angive en metodereference, der udtrækker det felt, der skal sammenlignes.

Comparator.comparing(Book::getTitle)

Flerstrenget sortering

Hvis der er behov for at sortere efter flere kriterier, kan metoden thenComparing anvendes:

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

Omvendt sortering

Metoderne reversed() og Comparator.reverseOrder() hjælper med at styre sorteringsretningen, men de fungerer forskelligt.

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øger vises først, og inden for samme år sorteres titlerne fra Z til A.

Forskelle mellem Comparable og Comparator

1. Hvornår skal `Comparable`-interfacet anvendes?

2. Hvornår skal `Comparator`-interfacet anvendes?

Var alt klart?

Tak for dine kommentarer!

Sektion 1. Kapitel 9

Comparator: Brugerdefineret Sammenligning af Data

Hvad er Comparator?

Praktisk anvendelse

Flerstrenget sortering

Omvendt sortering

Forskelle mellem Comparable og Comparator

1. Hvornår skal Comparable-interfacet anvendes?

2. Hvornår skal Comparator-interfacet anvendes?

Awesome!

Comparator: Brugerdefineret Sammenligning af Data

Hvad er Comparator?

Praktisk anvendelse

Flerstrenget sortering

Omvendt sortering

Forskelle mellem Comparable og Comparator

1. Hvornår skal Comparable-interfacet anvendes?

2. Hvornår skal Comparator-interfacet anvendes?

1. Hvornår skal `Comparable`-interfacet anvendes?

2. Hvornår skal `Comparator`-interfacet anvendes?

1. Hvornår skal `Comparable`-interfacet anvendes?

2. Hvornår skal `Comparator`-interfacet anvendes?