Java 8 - Мощно сравнение с Lambdas

1. Общ преглед

В този урок ще разгледаме за първи път поддръжката на Lambda в Java 8 - по-конкретно как да я използваме, за да напишем сравнителя и да сортираме колекция .

Тази статия е част от поредицата „Java - Back to Basic“ тук на Baeldung.

Първо, нека дефинираме прост клас на обект:

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

2. Основно сортиране без ламбда

Преди Java 8 сортирането на колекция ще включва създаване на анонимен вътрешен клас за сравнителя, използван в сортирането:

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

Това просто ще се използва за сортиране на списъка с човешки същества:

@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. Основно сортиране с ламбда поддръжка

С въвеждането на Lambdas вече можем да заобиколим анонимния вътрешен клас и да постигнем същия резултат с проста, функционална семантика :

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

По същия начин - вече можем да тестваме поведението точно както преди:

@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))); }

Забележете, че използваме и новия API за сортиране, добавен към java.util.List в Java 8 - вместо стария API на Collections.sort .

4. Основно сортиране без дефиниции на типа

Можем по-нататък да опростим израза, като не посочваме дефинициите на типа - компилаторът е в състояние да ги изведе сам:

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

И отново, тестът остава много подобен:

@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. Сортиране с помощта на препратка към статичен метод

След това ще извършим сортирането с помощта на Lambda Expression с препратка към статичен метод.

Първо ще дефинираме метода compareByNameThenAge - с точно същия подпис като метода за сравнение в обект 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); } }

Сега ще извикаме метода human.sort с тази препратка:

humans.sort(Human::compareByNameThenAge);

Крайният резултат е работно сортиране на колекцията, използвайки статичния метод като Comparator :

@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. Сортиране на извлечени компаратори

Можем също така да се избегне определянето дори сравнение самата логика, като използвате например референтен метод и Comparator.comparing метод - което екстракти и създава Сравними въз основа на тази функция.

Ще използваме getter getName (), за да изградим ламбда израза и да сортираме списъка по име:

@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. Обратно сортиране

JDK 8 също така въведе помощен метод за обръщане на компаратора - можем да го използваме бързо, за да обърнем нашия сорт:

@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. Сортиране с множество условия

Ламбда изразите за сравнение не е необходимо да са толкова прости - можем да напишем и по-сложни изрази - например сортиране на обектите първо по име, а след това по възраст:

@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. Сортиране с множество условия - Състав

Същата логика за сравнение - първо сортиране по име, а след това, на второ място, по възраст - може да бъде внедрена и от новата поддръжка на композиция за Comparator .

Започвайки с JDK 8, вече можем да свържем множество компаратори, за да изградим по-сложна логика за сравнение:

@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. Сортиране на списък с Stream.sorted ()

Можем също да сортираме колекция, като използваме API на Java 8 Stream sorted () .

Можем да сортираме потока, като използваме естествено подреждане, както и подреждане, предоставено от компаратор. За това имаме два претоварени варианта на API на sorted () :

  • sort ed () - сортира елементите на поток, използвайки естествено подреждане; класът на елементите трябва да реализира сравним интерфейс.
  • 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.