Een vergelijker in Java 8 omkeren

Ik heb een ArrayList en wil deze in aflopende volgorde sorteren. Ik gebruik ervoor de methode java.util.stream.Stream.sorted(Comparator). Hier is een beschrijving volgens Java API:

Retourneert een stream die bestaat uit de elementen van deze stream, gesorteerd volgens de verstrekte Comparator.

deze methode geeft me een sortering met oplopende volgorde. Welke parameter moet ik veranderen, alleen om de aflopende volgorde te hebben?

Antwoord 1, autoriteit 100%

U kunt Comparator.reverseOrder()om een ​​comparator te hebben die het omgekeerde van de natuurlijke volgorde geeft.

Als u de volgorde van een bestaande comparator wilt omkeren, kunt u Comparator.reversed().

Voorbeeldcode:

Stream.of(1, 4, 2, 5)
    .sorted(Comparator.reverseOrder()); 
    // stream is now [5, 4, 2, 1]
Stream.of("foo", "test", "a")
    .sorted(Comparator.comparingInt(String::length).reversed()); 
    // stream is now [test, foo, a], sorted by descending length

Antwoord 2, autoriteit 16%

Je kunt ook Comparator.comparing(Function, Comparator)
Het is handig om vergelijkers te koppelen als dat nodig is, bijvoorbeeld:

Comparator<SomeEntity> ENTITY_COMPARATOR = 
        Comparator.comparing(SomeEntity::getProperty1, Comparator.reverseOrder())
        .thenComparingInt(SomeEntity::getProperty2)
        .thenComparing(SomeEntity::getProperty3, Comparator.reverseOrder());

Antwoord 3, autoriteit 5%

Java 8 Comparator-interface heeft een reversed-methode: https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#reversed–

Antwoord 4

Ik vond deze vraag zoeken naar het omkeren van de volgorde als je een aangepaste vergelijker hebt en het omgekeerde is voorwaardelijk (je kunt het of niet).

Het idee van Pinocchio heeft me geholpen.

Dus hier is de code:

int order = requestedOrder.equals("asc") ? 1 : -1;
Collections.sort(List<CustomObj>, new Comparator<CustomObj>() {
    public int compare(CustomObj first, CustomObj scnd) {
        return first.getComparableParam().compareTo(scnd.getComparableParam()) * order;
    }
});

Hopelijk helpt het iemand anders in de toekomst

Antwoord 5

Waarom niet de bestaande comperator uitbreiden en super en noch het resultaat overschrijven.
De implementatie van de Comperator Interface is niet noodzakelijk, maar het maakt het duidelijker wat er gebeurt.

Als resultaat krijg je een gemakkelijk herbruikbaar klassenbestand, een testbare eenheidsstap en een duidelijke javadoc.

public class NorCoperator extends ExistingComperator implements Comparator<MyClass> {
    @Override
    public int compare(MyClass a, MyClass b) throws Exception {
        return super.compare(a, b)*-1;
    }
}