Reverse a comparator in Java 8
JavaSortingJava 8ComparatorJava StreamJava Problem Overview
I have an ArrayList and want sort it in descending order. I use for it java.util.stream.Stream.sorted(Comparator)
method. Here is a description according Java API:
> Returns a stream consisting of the elements of this stream, sorted according to the provided Comparator
.
this methods return me a sort with ascending order. Which parameter should I change, just to have the descending order?
Java Solutions
Solution 1 - Java
You can use Comparator.reverseOrder()
to have a comparator giving the reverse of the natural ordering.
If you want to reverse the ordering of an existing comparator, you can use Comparator.reversed()
.
Sample code:
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
Solution 2 - Java
You can also use Comparator.comparing(Function, Comparator)
It is convenient to chain comparators when necessary, e.g.:
Comparator<SomeEntity> ENTITY_COMPARATOR =
Comparator.comparing(SomeEntity::getProperty1, Comparator.reverseOrder())
.thenComparingInt(SomeEntity::getProperty2)
.thenComparing(SomeEntity::getProperty3, Comparator.reverseOrder());
Solution 3 - Java
Java 8 Comparator
interface has a reversed
method : https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#reversed--
Solution 4 - Java
I found this question serching for reversing order when you have a custom comparator and the reverse is conditional (you can do it or not).
The idea proposed by Pinocchio helped me.
So here is the 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;
}
});
Hope it helps somebody else in the future
Solution 5 - Java
Why not to extend the existing comperator and overwrite super and nor the result. The implementation the Comperator Interface is not nessesery but it makes it more clear what happens.
In result you get a easy reusable Class File, testable unit step and clear 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;
}
}