Use Comparator.comparing to make the comparators. Just figure out what you want to compare. It will looks something like this, except you will write whatever logic you want to use to extract the values to compare:
Comparator<Parent> byAttr1ofFirstChild = Comparator.comparing(
parent -> parent.getChildren().get(0).getAttr1()
);
Comparator<Parent> byAttr1ofFirstGrandChild = Comparator.comparing(
parent -> parent.getChildren().get(0).getGrandChildren().get(0).getAttr1()
);
List<Parent> sortedList = parents.stream()
.sorted(byAttr1ofFirstChild.thenComparing(byAttr1ofFirstGrandChild))
.collect(toList());
Comparator.comparing would also make the examples in your question much nicer (using static imports) :
Comparator<Parent> byFirst = comparing(Parent::getAttrib1, reverseOrder());
Comparator<Parent> bySecond = comparing(Parent::getAttrib2);
Videos
is
Comparator.comparing()used for converting a single argument lambda expression to a double argument?
Yes, you can sort of think of it like that.
When sorting things, you are supposed to specify "given two things a and b, which of them is greater, or are they equal?" using a Comparator<T>. The a and b is why it has 2 lambda parameters, and you return an integer indicating your answer to that question.
However, a much more convenient way to do this is to specify "given a thing x, what part of x do you want to sort by?". And that is what you can do with the keyExtractor argument of Comparator.comparing.
Compare:
/*
given two people, a and b, the comparison result between a and b is the
comparison result between a's name and b's name
*/
Comparator<Person> personNameComparator =
(a, b) -> a.getName().compareTo(b.getName());
/*
given a person x, compare their name
*/
Comparator<Person> personNameComparator =
Comparator.comparing(x -> x.getName()); // or Person::getName
The latter is clearly much more concise and intuitive. We tend to think about what things to sort by, rather than how exactly to compare two things, and the exact number to return depending on the comparison result.
As for the declaration for comparing:
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor)
The <T, U extends Comparable<? super U>> part first declares two generic type parameters - T is what the comparator compares (Person in the above case), and U is the type that you are actually comparing (String in the above case), hence it extends Comparable.
keyExtractor is the parameter you pass in, such as x -> x.getName(), that should answer the question of "when given a T, what is a U that you want to compare by?".
If you are confused by the ? super and ? extends, read What is PECS?.
If you haven't realised already, the implementation of comparing basically boils down to:
return (a, b) -> keyExtractor.apply(a).compareTo(keyExtractor.apply(b));
Comparator#compare(T o1, T o2) Compare two objects and returns an integer value based on this criteria:
- A negative value if o1 < o2
- A positive value if o1 > o2
- Zero if they are equal.
Comparator.comparing(Function<? super T, ? extends U> key) returns a Comparator<T> that compares by that sort key.
The main difference is that compare method provides a single point of comparison, whereas comparing chained to other functions to provide multiple points of comparison.
Suppose you have a class Person
public class Person implements Comparable<Person> {
private String firstName;
private String lastName;
private int age;
// rest of class omitted
}
if you compare two Person instances p1 vs p2 using compare(p1, p2), the comparison will be executed and the two objects will be sorted based on some natural ordering prescribed by the class. In contrast, if you want to compare the same two instances using comparing(), the comparison will be executed based on whichever criteria you choose to compare based on some attribute of the class. For example: Comparator.comparing(Person::getFirstName).
Because comparing returns a Comparator rather than a value, as I stated before, you can chain multiple comparisons. For instance: Comparator.comparing(Person::getLastName).thenComparing(Person::getFirstName);
As for the meaning of the return type <T, U extends Comparable<? super U>> Comparator<T>, you can find the explanation here.
I want to add that, classes must be comparable in order for compare(T o1, T o2) to work. String objects are comparable because they implement this interface. That said, if a class is not Comparable, you can still use comparing method because as I stated, you get to choose which attribute of the class you would like to use for the comparison and those attributes are likely to be comparable (i.e. String in the case of person's name or age in the above example).
It seems that the compiler can not infer the correct types (I've tried javac 8 and 9 with the same effect). The only way I could make it work is specifying the types directly via casting:
list.stream()
.sorted(
Comparator.comparing((List<Object> o) -> o.get(3).toString())
.thenComparing((List<Object> x) -> x.get(3).toString()));
I have also had these problems a couple of times, especially with Comparator. Eclipse and/or the java compiler have trouble infering the types correctly. As Holger pointed out, this is not a bug but working as specified: The types in the Comparator cannot be inferred solely by the expected type of sorted's parameter. You have to type manually/explicitly to give it enough info to compile:
List<List<Object>> listOutput = new ArrayList<>();
listOutput = listOutput.stream()
.sorted(Comparator.comparing((List<Object> o) -> o.get(3).toString())
.thenComparing(o -> o.get(2).toString()))
.collect(Collectors.toList());
In the subsequent thenComparings the type is then correctly recognized.