I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE COURSE

1. Overview

In this tutorial, we’re going to take a first look at the Lambda support in Java 8 – specifically at how to leverage it to write the Comparator and sort a Collection.

This article is part of the “Java – Back to Basic” series here on Baeldung.

Further reading:

The Java 8 Stream API Tutorial

The article is an example-heavy introduction of the possibilities and operations offered by the Java 8 Stream API.

Read more

Guide to Java 8’s Collectors

The article discusses Java 8 Collectors, showing examples of built-in collectors, as well as showing how to build custom collector.

Read more

Lambda Expressions and Functional Interfaces: Tips and Best Practices

Tips and best practices on using Java 8 lambdas and functional interfaces.

Read more

First, let’s define a simple entity class:

public class Human {
    private String name;
    private int age;

    // standard constructors, getters/setters, equals and hashcode
}

2. Basic Sort without Lambdas

Before Java 8, sorting a collection would involve creating an anonymous inner class for the Comparator used in the sort:

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

This would simply be used to sort the List of Human entities:

@Test
public void givenPreLambda_whenSortingEntitiesByName_thenCorrectlySorted() {
    List<Human> humans = Lists.newArrayList(
      new Human("Sarah", 10), 
      new Human("Jack", 12)
    );
    
    Collections.sort(humans, new Comparator<Human>() {
        @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. Basic Sort with Lambda Support

With the introduction of Lambdas, we can now bypass the anonymous inner class and achieve the same result with simple, functional semantics:

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

Similarly – we can now test the behavior just as before:

@Test
public void whenSortingEntitiesByName_thenCorrectlySorted() {
    List<Human> 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)));
}

Notice that we’re also using the new sort API added to java.util.List in Java 8 – instead of the old Collections.sort API.

4. Basic Sorting with no Type Definitions

We can further simplify the expression by not specifying the type definitions – the compiler is capable of inferring these on its own:

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

And again, the test remains very similar:

@Test
public void 
  givenLambdaShortForm_whenSortingEntitiesByName_thenCorrectlySorted() {
    
    List<Human> 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. Sort using Reference to Static Method

Next, we’re going to perform the sort using a Lambda Expression with a reference to a static method.

First, we’re going to define the method compareByNameThenAge – with the exact same signature as the compare method in a Comparator<Human> object:

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

Now, we’re going to call the humans.sort method with this reference:

humans.sort(Human::compareByNameThenAge);

The end result is a working sorting of the collection using the static method as a Comparator:

@Test
public void 
  givenMethodDefinition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
    
    List<Human> 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. Sort Extracted Comparators

We can also avoid defining even the comparison logic itself by using an instance method reference and the Comparator.comparing method – which extracts and creates a Comparable based on that function.

We’re going to use the getter getName() to build the Lambda expression and sort the list by name:

@Test
public void 
  givenInstanceMethod_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
    
    List<Human> 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. Reverse Sort

JDK 8 has also introduced a helper method for reversing the comparator – we can make quick use of that to reverse our sort:

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

8. Sort with Multiple Conditions

The comparison lambda expressions need not be this simple – we can write more complex expressions as well – for example sorting the entities first by name, and then by age:

@Test
public void whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
    List<Human> 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 lhs.getAge() - rhs.getAge();
        } else {
            return lhs.getName().compareTo(rhs.getName());
        }
    });
    Assert.assertThat(humans.get(0), equalTo(new Human("Sarah", 10)));
}

9. Sort with Multiple Conditions – Composition

The same comparison logic – first sorting by name and then, secondarily, by age – can also be implemented by the new composition support for Comparator.

Starting with JDK 8, we can now chain together multiple comparators to build more complex comparison logic:

@Test
public void 
  givenComposition_whenSortingEntitiesByNameThenAge_thenCorrectlySorted() {
    
    List<Human> 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. Sorting a List with Stream.sorted()

We can also sort a collection using Java 8’s Stream sorted() API. 

We can sort the stream using natural ordering as well as ordering provided by a Comparator. For this, we have two overloaded variants of the sorted() API:

  • sorted() sorts the elements of a Stream using natural ordering; the element class must implement the Comparable interface.
  • 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<String> letters = Lists.newArrayList("B", "A", "C");
	
    List<String> 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<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
    Comparator<Human> nameComparator = (h1, h2) -> h1.getName().compareTo(h2.getName());
	
    List<Human> sortedHumans = humans.stream().sorted(nameComparator).collect(Collectors.toList());
    assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12)));
}

11. Conclusion

This articles 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 in the GitHub project – this is an Eclipse based project, so it should be easy to import and run as it is.

I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE LESSONS

newest oldest most voted
Notify of
Michel Graciano
Guest
Michel Graciano

Great article. It is really educating to see the evolution you used to illustrate the new features.
I just want to suggest that instead using Ints.compare you now can use Integer.compare and avoid a dependence for this simple example.

Thanks and congratulations about your article.

Eugen Paraschiv
Guest

Hey Michael – nice catch – I’ll go ahead and update the article first thing tomorrow.
Cheers,
Eugen.

Ashutosh
Guest
Ashutosh

Can you provide some examples how to use Iterables & Predicates

Eugen Paraschiv
Guest

Iterables and Predicates for sorting, or just in general?

Richard Langlois
Guest

Cool stuff ! Can’t wait to use Java 8 in my next project…

Eugen Paraschiv
Guest

Yeah, I’ve been using it for a few months and I keep finding better and better ways to improve the code I write by using stuff like the new Stream API, or Optional. Cool stuff indeed. Cheers,
Eugen.

mikenhill
Guest
mikenhill

As the code stands, the following line: “Assert.assertThat(humans.get(0), equalTo(new Human(“Jack”, 12)));”

Will compare two different object references which are not equal. Would it be better to use:

Assert.assertThat(humans.get(0).getName(), equalTo(new Human(“Jack”, 12).getName()));

Eugen Paraschiv
Guest

Yeah – you can definitely use the names. In this case, it doesn’t really matter because the objects are equal according to the implementation of equals in User (which looks at age and name), but generally, if it’s not safe to use the full value, you can and should certainly use the fields you’re interested in. Cheers,
Eugen.

Carlos Mollapaza
Guest
Carlos Mollapaza

WHERE IS “Lists.newArrayList”

Eugen Paraschiv
Guest

Hey Carlos – it’s where it belongs – in Guava 🙂
Joking aside – why would this be relevant for sorting? I’d be happy to add it in if it is. Cheers,
Eugen.

Phạm Công Quân
Guest
Phạm Công Quân

His very good article, you have a video of this tutorial is not so, if you ask for links, thank you very much

Eugen Paraschiv
Guest

Hey Phạm, no video of this one. Only a handful of my writeups also have videos. Cheers,
Eugen.

Phạm Công Quân
Guest
Phạm Công Quân

ok, thanks