Lära Komparator: Anpassad Jämförelse av Data | Grunder och Funktionella Möjligheter med Stream API

Låt oss titta på det andra funktionella gränssnittet, Comparator, se hur det implementerar jämförelse och förstå skillnaden mellan Comparator och Comparable.

Vad är Comparator?

Den viktigaste metoden i det funktionella gränssnittet Comparator är:

int compare(T o1, T o2);

Metoden compare(T o1, T o2) returnerar:

Ett negativt tal om o1 är mindre än o2;
Noll om o1 och o2 är lika;
Ett positivt tal om o1 är större än o2.

Praktisk tillämpning

Implementering av sortering av Book-objekt med hjälp av Comparator-gränssnittet. Istället för att implementera jämförelsemetoden i själva Book-klassen används statisk metoder från Comparator-gränssnittet för att definiera sorteringslogiken.

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 detta exempel används Comparator-gränssnittet för att sortera listan books. Men varför användes metoden comparing() istället för compare()?

Om du vill använda metoden compare() behöver du skapa ett Comparator-objekt och implementera compare-metoden.

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

Denna kod definierar en Comparator<Book> med hjälp av en anonym klass för att jämföra två Book-objekt baserat på deras title.

Eftersom String implementerar Comparable används metoden compareTo() för att jämföra titlarna lexikografiskt, vilket returnerar ett negativt, noll eller positivt värde.

Alternativt kan samma resultat uppnås med ett lambda-uttryck för en mer koncis implementation:

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

Men det finns ett ännu enklare tillvägagångssätt: att använda metoden Comparator.comparing(). Denna metod hanterar automatiskt jämförelselogiken åt dig, vilket gör koden mer lättläst och koncis.

Du skickar helt enkelt en metodreferens som extraherar det fält som ska jämföras.

Comparator.comparing(Book::getTitle)

Listans sort()-metod anropar den angivna Comparator, som i sin tur bestämmer ordningen på elementen genom att jämföra dem baserat på de värden som returneras av de angivna metoderna.

Flera sorteringskriterier

För att sortera efter flera kriterier kan du använda metoden thenComparing:

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

Detta exempel visar hur en lista med böcker kan sorteras först efter deras utgivningsyear och därefter efter title. Sorteringsprocessen jämför först böckerna baserat på deras year, och om två böcker har samma year jämförs de sedan efter title för att avgöra deras slutliga ordning.

Omvänd sortering

Omvänd sorteringsordning i Java är användbart när det behövs att sortera element efter ett kriterium först och sedan ändra ordningen för nästa kriterium.

Metoderna reversed() och Comparator.reverseOrder() hjälper till att styra sorteringsriktningen, men de fungerar på olika sätt.

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

Böckerna sorteras först efter deras utgivningsår i fallande ordning med hjälp av reversed(). Om flera böcker har samma year, sorterar thenComparing() dem efter title i omvänd alfabetisk ordning med Comparator.reverseOrder().

Detta säkerställer att de senaste böckerna visas först, och inom samma år ordnas titlarna från Z till A.

Skillnader mellan Comparable och Comparator

Använd Comparable-gränssnittet när en klass har en naturlig ordning, till exempel sortering efter ett enskilt fält. Använd Comparator när du sorterar efter flera kriterier eller när du behöver definiera en anpassad ordning för objekt.

1. När ska man använda gränssnittet `Comparable`?

2. När ska man använda gränssnittet `Comparator`?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 9

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

Awesome!

Completion rate improved to 2.33

Svep för att visa menyn

Låt oss titta på det andra funktionella gränssnittet, Comparator, se hur det implementerar jämförelse och förstå skillnaden mellan Comparator och Comparable.

Vad är Comparator?

Den viktigaste metoden i det funktionella gränssnittet Comparator är:

int compare(T o1, T o2);

Metoden compare(T o1, T o2) returnerar:

Ett negativt tal om o1 är mindre än o2;
Noll om o1 och o2 är lika;
Ett positivt tal om o1 är större än o2.

Praktisk tillämpning

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 detta exempel används Comparator-gränssnittet för att sortera listan books. Men varför användes metoden comparing() istället för compare()?

Om du vill använda metoden compare() behöver du skapa ett Comparator-objekt och implementera compare-metoden.

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

Denna kod definierar en Comparator<Book> med hjälp av en anonym klass för att jämföra två Book-objekt baserat på deras title.

Eftersom String implementerar Comparable används metoden compareTo() för att jämföra titlarna lexikografiskt, vilket returnerar ett negativt, noll eller positivt värde.

Alternativt kan samma resultat uppnås med ett lambda-uttryck för en mer koncis implementation:

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

Du skickar helt enkelt en metodreferens som extraherar det fält som ska jämföras.

Comparator.comparing(Book::getTitle)

Flera sorteringskriterier

För att sortera efter flera kriterier kan du använda metoden thenComparing:

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

Omvänd sortering

Omvänd sorteringsordning i Java är användbart när det behövs att sortera element efter ett kriterium först och sedan ändra ordningen för nästa kriterium.

Metoderna reversed() och Comparator.reverseOrder() hjälper till att styra sorteringsriktningen, men de fungerar på olika sätt.

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

Detta säkerställer att de senaste böckerna visas först, och inom samma år ordnas titlarna från Z till A.

Skillnader mellan Comparable och Comparator

1. När ska man använda gränssnittet `Comparable`?

2. När ska man använda gränssnittet `Comparator`?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 1. Kapitel 9

Komparator: Anpassad Jämförelse av Data

Vad är Comparator?

Praktisk tillämpning

Flera sorteringskriterier

Omvänd sortering

Skillnader mellan Comparable och Comparator

1. När ska man använda gränssnittet Comparable?

2. När ska man använda gränssnittet Comparator?

Awesome!

Komparator: Anpassad Jämförelse av Data

Vad är Comparator?

Praktisk tillämpning

Flera sorteringskriterier

Omvänd sortering

Skillnader mellan Comparable och Comparator

1. När ska man använda gränssnittet Comparable?

2. När ska man använda gränssnittet Comparator?

1. När ska man använda gränssnittet `Comparable`?

2. När ska man använda gränssnittet `Comparator`?

1. När ska man använda gränssnittet `Comparable`?

2. När ska man använda gränssnittet `Comparator`?