Laten we de tweede functionele interface, Comparator, bekijken, zien hoe deze vergelijking implementeert en het verschil tussen Comparator en Comparable begrijpen.

Wat is Comparator?

De belangrijkste methode in de functionele interface Comparator is:

int compare(T o1, T o2);

De methode compare(T o1, T o2) retourneert:

• Een negatief getal als o1 kleiner is dan o2;
• Nul als o1 en o2 gelijk zijn;
• Een positief getal als o1 groter is dan o2.

Praktische Toepassing

Implementeer het sorteren van Book-objecten met behulp van de interface Comparator. In plaats van de vergelijkingsmethode binnen de klasse Book zelf te implementeren, gebruik je statische methoden van de interface Comparator om de sorteerlogica te definiëren.

In dit voorbeeld wordt de Comparator-interface gebruikt om de lijst books te sorteren. Maar waarom is de comparing()-methode gebruikt in plaats van compare()?

Als je de compare()-methode wilt gebruiken, moet je een Comparator-object aanmaken en de compare-methode implementeren.

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

Deze code definieert een Comparator<Book> met behulp van een anonieme klasse om twee Book-objecten te vergelijken op basis van hun title.

Aangezien String de Comparable-interface implementeert, wordt de compareTo()-methode gebruikt om de titels lexicografisch te vergelijken, wat een negatieve, nul of positieve waarde oplevert.

Als alternatief kan hetzelfde resultaat worden bereikt met een lambda-expressie voor een meer beknopte implementatie:

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

Maar er is een nog eenvoudigere benadering: het gebruik van de methode Comparator.comparing(). Deze methode regelt automatisch de vergelijkingslogica voor je, waardoor het leesbaarder en bondiger wordt.

Je geeft eenvoudigweg een methode-referentie door die het veld voor vergelijking extraheert.

Comparator.comparing(Book::getTitle)

De methode sort() van de lijst roept de meegegeven Comparator aan, die op zijn beurt de volgorde van elementen bepaalt door ze te vergelijken op basis van de waarden die door de opgegeven methoden worden geretourneerd.

Meervoudig Sorteren

Indien sortering op meerdere criteria vereist is, kan de thenComparing-methode worden gebruikt:

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

Dit voorbeeld toont hoe een lijst van boeken eerst op hun uitgaveyear en vervolgens op title kan worden gesorteerd. Het sorteerproces vergelijkt de boeken eerst op basis van hun year, en als twee boeken hetzelfde year hebben, worden ze op title vergeleken om de definitieve volgorde te bepalen.

Omgekeerd Sorteren

Het omkeren van de sorteervolgorde in Java is nuttig wanneer elementen eerst op één criterium gesorteerd moeten worden en vervolgens de volgorde voor het volgende criterium gewijzigd moet worden.

De reversed()- en Comparator.reverseOrder()-methoden bieden controle over de sorteerrichting, maar functioneren verschillend.

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

De boeken worden eerst gesorteerd op hun uitgavejaar in aflopende volgorde met behulp van reversed(). Als meerdere boeken hetzelfde year hebben, sorteert thenComparing() ze op title in omgekeerde alfabetische volgorde met behulp van Comparator.reverseOrder().

Hierdoor verschijnen de meest recente boeken eerst en worden binnen hetzelfde jaar de titels van Z tot A gerangschikt.

Verschillen tussen Comparable en Comparator

Gebruik de Comparable interface wanneer een klasse een natuurlijke ordening heeft, zoals sorteren op een enkel veld. Gebruik Comparator wanneer er op meerdere criteria gesorteerd moet worden of wanneer een aangepaste volgorde voor objecten vereist is.