Java 8 – Lambda와의 강력한 비교

1. 개요

이 자습서에서는 Java 8Lambda 지원, 특히이를 활용하여 Comparator 를 작성하고 컬렉션을 정렬하는 방법에 대해 먼저 살펴 보겠습니다 .

이 기사는 Baeldung에 대한 "Java – Back to Basic"시리즈의 일부입니다.

먼저 간단한 엔티티 클래스를 정의하겠습니다.

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

2. 람다가없는 기본 정렬

Java 8 이전에는 컬렉션 정렬에 정렬에 사용 된 Comparator에 대한 익명 내부 클래스 생성 이 포함 됩니다.

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. Lambda 지원을 통한 기본 정렬

Lambda가 도입됨에 따라 이제 익명의 내부 클래스를 우회하고 단순하고 기능적인 의미 체계로 동일한 결과를 얻을 수 있습니다 .

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

이전 Collections.sort API 대신 Java 8의 java.util.List추가 된 새로운 정렬 API 도 사용 하고 있습니다.

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 식을 사용하여 정렬을 수행합니다.

먼저 Comparator 개체 의 비교 메서드 와 정확히 동일한 서명 을 사용하여 compareByNameThenAge 메서드를 정의 합니다.

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

이제 다음 참조를 사용 하여 humans.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. 추출 된 비교기 정렬

또한 인스턴스 메서드 참조 와 해당 함수를 기반으로 Comparable 을 추출하고 생성하는 Comparator.comparing 메서드 를 사용하여 비교 논리 자체도 정의하는 것을 피할 수 있습니다 .

getter getName () 을 사용하여 Lambda 표현식을 빌드하고 이름별로 목록을 정렬 할 것입니다.

@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 () 로 목록 정렬

Java 8의 Stream sorted () API를 사용하여 컬렉션을 정렬 할 수도 있습니다 .

자연 순서와 비교기에서 제공하는 순서를 사용하여 스트림을 정렬 할 수 있습니다 . 이를 위해 sorted () API 의 두 가지 오버로드 된 변형이 있습니다 .

  • sort ed () 자연 순서를 사용하여 Stream 의 요소를 정렬합니다 . 요소 클래스는 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.