Java 8 - Comparaison puissante avec Lambdas

1. Vue d'ensemble

Dans ce didacticiel, nous allons jeter un premier regard sur la prise en charge de Lambda dans Java 8, en particulier sur la façon de l'exploiter pour écrire le comparateur et trier une collection .

Cet article fait partie de la série «Java - Back to Basic» ici sur Baeldung.

Tout d'abord, définissons une classe d'entité simple:

public class Human { private String name; private int age; // standard constructors, getters/setters, equals and hashcode } 

2. Tri de base sans lambdas

Avant Java 8, le tri d'une collection impliquait la création d'une classe interne anonyme pour le comparateur utilisé dans le tri:

new Comparator() { @Override public int compare(Human h1, Human h2) { return h1.getName().compareTo(h2.getName()); } }

Ce serait tout simplement utilisé pour trier la liste des humains entités:

@Test public void givenPreLambda_whenSortingEntitiesByName_thenCorrectlySorted() { List humans = Lists.newArrayList( new Human("Sarah", 10), new Human("Jack", 12) ); Collections.sort(humans, new Comparator() { @Override public int compare(Human h1, Human h2) { return h1.getName().compareTo(h2.getName()); } }); Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); }

3. Tri de base avec prise en charge Lambda

Avec l'introduction de Lambdas, nous pouvons désormais contourner la classe interne anonyme et obtenir le même résultat avec une sémantique simple et fonctionnelle :

(final Human h1, final Human h2) -> h1.getName().compareTo(h2.getName());

De même - nous pouvons maintenant tester le comportement comme avant:

@Test public void whenSortingEntitiesByName_thenCorrectlySorted() { List humans = Lists.newArrayList( new Human("Sarah", 10), new Human("Jack", 12) ); humans.sort( (Human h1, Human h2) -> h1.getName().compareTo(h2.getName())); assertThat(humans.get(0), equalTo(new Human("Jack", 12))); }

Notez que nous utilisons également la nouvelle API de tri ajoutée à java.util.List dans Java 8 - au lieu de l'ancienne API Collections.sort .

4. Tri de base sans définition de type

Nous pouvons encore simplifier l'expression en ne spécifiant pas les définitions de type - le compilateur est capable de les inférer lui-même:

(h1, h2) -> h1.getName().compareTo(h2.getName())

Et encore une fois, le test reste très similaire:

@Test public void givenLambdaShortForm_whenSortingEntitiesByName_thenCorrectlySorted() { List humans = Lists.newArrayList( new Human("Sarah", 10), new Human("Jack", 12) ); humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName())); assertThat(humans.get(0), equalTo(new Human("Jack", 12))); }

5. Trier en utilisant la méthode de référence à la méthode statique

Ensuite, nous allons effectuer le tri à l'aide d'une expression Lambda avec une référence à une méthode statique.

Tout d'abord, nous allons définir la méthode compareByNameThenAge - avec exactement la même signature que la méthode compare dans un objet Comparator :

public static int compareByNameThenAge(Human lhs, Human rhs) { if (lhs.name.equals(rhs.name)) { return Integer.compare(lhs.age, rhs.age); } else { return lhs.name.compareTo(rhs.name); } }

Maintenant, nous allons appeler la méthode human.sort avec cette référence:

humans.sort(Human::compareByNameThenAge);

Le résultat final est un tri fonctionnel de la collection en utilisant la méthode statique comme comparateur :

@Test public void givenMethodDefinition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { List humans = Lists.newArrayList( new Human("Sarah", 10), new Human("Jack", 12) ); humans.sort(Human::compareByNameThenAge); Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12))); }

6. Trier les comparateurs extraits

Nous pouvons également éviter de définir même la logique de comparaison elle-même en utilisant une référence de méthode d'instance et la méthode Comparator.comparing - qui extrait et crée un Comparable basé sur cette fonction.

Nous allons utiliser le getter getName () pour créer l'expression Lambda et trier la liste par nom:

@Test public void givenInstanceMethod_whenSortingEntitiesByName_thenCorrectlySorted() { List humans = Lists.newArrayList( new Human("Sarah", 10), new Human("Jack", 12) ); Collections.sort( humans, Comparator.comparing(Human::getName)); assertThat(humans.get(0), equalTo(new Human("Jack", 12))); }

7. Tri inversé

JDK 8 a également introduit une méthode d'aide pour inverser le comparateur - nous pouvons l'utiliser rapidement pour inverser notre tri:

@Test public void whenSortingEntitiesByNameReversed_thenCorrectlySorted() { List humans = Lists.newArrayList( new Human("Sarah", 10), new Human("Jack", 12) ); Comparator comparator = (h1, h2) -> h1.getName().compareTo(h2.getName()); humans.sort(comparator.reversed()); Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); }

8. Trier avec plusieurs conditions

Les expressions lambda de comparaison n'ont pas besoin d'être aussi simples - nous pouvons également écrire des expressions plus complexes - par exemple en triant les entités d'abord par nom, puis par âge:

@Test public void whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { List humans = Lists.newArrayList( new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12) ); humans.sort((lhs, rhs) -> { if (lhs.getName().equals(rhs.getName())) { return Integer.compare(lhs.getAge(), rhs.getAge()); } else { return lhs.getName().compareTo(rhs.getName()); } }); Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); }

9. Trier avec plusieurs conditions - Composition

La même logique de comparaison - tri d'abord par nom puis, secondairement, par âge - peut également être implémentée par le nouveau support de composition de Comparator .

À partir de JDK 8, nous pouvons désormais enchaîner plusieurs comparateurs pour créer une logique de comparaison plus complexe:

@Test public void givenComposition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() { List humans = Lists.newArrayList( new Human("Sarah", 12), new Human("Sarah", 10), new Human("Zack", 12) ); humans.sort( Comparator.comparing(Human::getName).thenComparing(Human::getAge) ); Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10))); }

10. Tri d'une liste avec Stream.sorted ()

Nous pouvons également trier une collection à l'aide de l'API Stream sorted () de Java 8 .

Nous pouvons trier le flux en utilisant l'ordre naturel ainsi que l'ordre fourni par un comparateur. Pour cela, nous avons deux variantes surchargées de l' API sorted () :

  • sort ed () - trie les éléments d'un Stream en utilisant l'ordre naturel; la classe d'élément doit implémenter l' interface Comparable .
  • sorted(Comparator super T> comparator) – sorts the elements based on a Comparator instance

Let's see an example of how to use the sorted() method with natural ordering:

@Test public final void givenStreamNaturalOrdering_whenSortingEntitiesByName_thenCorrectlySorted() { List letters = Lists.newArrayList("B", "A", "C"); List sortedLetters = letters.stream().sorted().collect(Collectors.toList()); assertThat(sortedLetters.get(0), equalTo("A")); }

Now let's see how we can use a custom Comparator with the sorted() API:

@Test public final void givenStreamCustomOrdering_whenSortingEntitiesByName_thenCorrectlySorted() { List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); Comparator nameComparator = (h1, h2) -> h1.getName().compareTo(h2.getName()); List sortedHumans = humans.stream().sorted(nameComparator).collect(Collectors.toList()); assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12))); }

We can simplify the above example even further if we use the Comparator.comparing() method:

@Test public final void givenStreamComparatorOrdering_whenSortingEntitiesByName_thenCorrectlySorted() { List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); List sortedHumans = humans.stream() .sorted(Comparator.comparing(Human::getName)) .collect(Collectors.toList()); assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12))); }

11. Sorting a List in Reverse With Stream.sorted()

We can also use Stream.sorted() to sort a collection in reverse.

First, let's see an example of how to combine the sorted() method with Comparator.reverseOrder() to sort a list in the reverse natural order:

@Test public final void givenStreamNaturalOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() { List letters = Lists.newArrayList("B", "A", "C"); List reverseSortedLetters = letters.stream() .sorted(Comparator.reverseOrder()) .collect(Collectors.toList()); assertThat(reverseSortedLetters.get(0), equalTo("C")); }

Now, let's see how we can use the sorted() method and a custom Comparator:

@Test public final void givenStreamCustomOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() { List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); Comparator reverseNameComparator = (h1, h2) -> h2.getName().compareTo(h1.getName()); List reverseSortedHumans = humans.stream().sorted(reverseNameComparator) .collect(Collectors.toList()); assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10))); }

Note that the invocation of compareTo is flipped, which is what is doing the reversing.

Finally, let's simplify the above example by using the Comparator.comparing() method:

@Test public final void givenStreamComparatorOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() { List humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12)); List reverseSortedHumans = humans.stream() .sorted(Comparator.comparing(Human::getName, Comparator.reverseOrder())) .collect(Collectors.toList()); assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10))); }

12. Null Values

So far, we implemented our Comparators in a way that they can't sort collections containing null values. That is, if the collection contains at least one null element, then the sort method throws a NullPointerException:

@Test(expected = NullPointerException.class) public void givenANullElement_whenSortingEntitiesByName_thenThrowsNPE() { List humans = Lists.newArrayList(null, new Human("Jack", 12)); humans.sort((h1, h2) -> h1.getName().compareTo(h2.getName())); }

The simplest solution is to handle the null values manually in our Comparator implementation:

@Test public void givenANullElement_whenSortingEntitiesByNameManually_thenMovesTheNullToLast() { List humans = Lists.newArrayList(null, new Human("Jack", 12), null); humans.sort((h1, h2) -> { if (h1 == null) { return h2 == null ? 0 : 1; } else if (h2 == null) { return -1; } return h1.getName().compareTo(h2.getName()); }); Assert.assertNotNull(humans.get(0)); Assert.assertNull(humans.get(1)); Assert.assertNull(humans.get(2)); }

Here we're pushing all null elements towards the end of the collection. To do that, the comparator considers null to be greater than non-null values. When both are null, they are considered equal.

Additionally, we can pass any Comparator that is not null-safe into the Comparator.nullsLast() method and achieve the same result:

@Test public void givenANullElement_whenSortingEntitiesByName_thenMovesTheNullToLast() { List humans = Lists.newArrayList(null, new Human("Jack", 12), null); humans.sort(Comparator.nullsLast(Comparator.comparing(Human::getName))); Assert.assertNotNull(humans.get(0)); Assert.assertNull(humans.get(1)); Assert.assertNull(humans.get(2)); }

Similarly, we can use Comparator.nullsFirst() to move the null elements towards the start of the collection:

@Test public void givenANullElement_whenSortingEntitiesByName_thenMovesTheNullToStart() { List humans = Lists.newArrayList(null, new Human("Jack", 12), null); humans.sort(Comparator.nullsFirst(Comparator.comparing(Human::getName))); Assert.assertNull(humans.get(0)); Assert.assertNull(humans.get(1)); Assert.assertNotNull(humans.get(2)); } 

It's highly recommended to use the nullsFirst() or nullsLast() decorators, as they're more flexible and, above all, more readable.

13. Conclusion

This article illustrated the various and exciting ways that a List can be sorted using Java 8 Lambda Expressions – moving right past syntactic sugar and into real and powerful functional semantics.

The implementation of all these examples and code snippets can be found over on GitHub.