Using Streams to Collect Into a TreeSet

1. Overview

One significant new feature in Java 8 is the Stream API. Streams allow us to process elements conveniently from different sources, such as arrays or collections.

Further, using the Stream.collect() method with corresponding Collectors, we can repack the elements to different data structures like Set, Map, List, and so on.

In this tutorial, we’ll explore how to collect elements in a Stream into a TreeSet.

2. Collecting Into a TreeSet With Natural Ordering

Simply put, the TreeSet is a sorted Set. The elements in a TreeSet are ordered using their natural ordering or a provided Comparator.

We’ll first look at how to collect Stream elements using their natural ordering. Then, let’s focus on collecting elements using custom Comparator cases.

For simplicity, we’ll use unit test assertions to verify if we’ve got the expected TreeSet result.

2.1. Collecting Strings Into a TreeSet

Since String implements the Comparable interface, let’s first take String as an example to see how to collect them in a TreeSet:

String kotlin = "Kotlin";
String java = "Java";
String python = "Python";
String ruby = "Ruby";
TreeSet<String> myTreeSet = Stream.of(ruby, java, kotlin, python).collect(Collectors.toCollection(TreeSet::new));
assertThat(myTreeSet).containsExactly(java, kotlin, python, ruby);

As the test above shows, to collect Stream elements into a TreeSet, we just pass TreeSet‘s default constructor as a method reference or a lambda expression to the Collectors.toCollection() method.

If we execute this test, it passes.

Next, let’s see a similar example with a custom class.

2.2. Collecting Players With Their Natural Ordering

First, let’s have a look at our Player class:

public class Player implements Comparable<Player> {
    private String name;
    private int age;
    private int numberOfPlayed;
    private int numberOfWins;

    public Player(String name, int age, int numberOfPlayed, int numberOfWins) {
        this.name = name;
        this.age = age;
        this.numberOfPlayed = numberOfPlayed;
        this.numberOfWins = numberOfWins;
    }

    @Override
    public int compareTo(Player o) {
        return Integer.compare(age, o.age);
    }

    // getters are omitted
}

As the class above shows, our Player class implements the Comparable interface. Further, we’ve defined its natural ordering in the compareTo() method: player’s age.

So next, let’s create a few Player instances:

/*                          name  |  age  | num of played | num of wins
                           --------------------------------------------- */
Player kai = new Player(   "Kai",     26,       28,            7);
Player eric = new Player(  "Eric",    28,       30,           11);
Player saajan = new Player("Saajan",  30,      100,           66);
Player kevin = new Player( "Kevin",   24,       50,           49);

As we’ll use these four player objects for other demonstrations later, we put the code in a table-like format to easily check each player’s attribute values.

Now, let’s collect them in a TreeSet with their natural order and verify if we have the expected result:

TreeSet<Player> myTreeSet = Stream.of(saajan, eric, kai, kevin).collect(Collectors.toCollection(TreeSet::new));
assertThat(myTreeSet).containsExactly(kevin, kai, eric, saajan);

As we can see, the code is pretty similar to collecting strings into a TreeSet. Since Player‘s compareTo() method has specified the “age” attribute as its natural ordering, we verify the result (myTreeSet) with the players sorted by age ascending.

It’s worth mentioning that we’ve used AssertJ‘s containsExactly() method to verify the TreeSet contains precisely the given elements in order and nothing else.

Next, we’ll look at how to collect these players into a TreeSet using a customized Comparator.

3. Collecting Into a TreeSet With a Customized Comparator

We’ve seen Collectors.toCollection(TreeSet::new) allows us to collect elements in a Stream to a TreeSet in their natural ordering. The TreeSet provides another constructor that accepts a Comparator object as the argument:

public TreeSet(Comparator<? super E> comparator) { ... }

Therefore, if we want the TreeSet to apply a different ordering on the elements, we can create a Comparator object and pass it to the constructor mentioned above.

Next, let’s collect these players in a TreeSet by their number of wins instead of their ages:

TreeSet<Player> myTreeSet = Stream.of(saajan, eric, kai, kevin)
  .collect(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparingInt(Player::getNumberOfWins))
));
assertThat(myTreeSet).containsExactly(kai, eric, kevin, saajan);

This time, we’ve used a lambda expression to create the TreeSet instance. Moreover, we’ve passed our own Comparator using Comparator.comparingInt() to the TreeSet‘s constructor.

Player::getNumberOfWins references the attribute’s value we need to compare players.

The test passes when we give it a run.

However, the required comparison logic is sometimes not as simple as just comparing an attribute’s value as the example shows. For example, we may need to compare the results of some additional calculations.

So finally, let’s collect these players in a TreeSet again. But this time, we want them to be sorted by their win rate (number of wins/number of played):

TreeSet<Player> myTreeSet = Stream.of(saajan, eric, kai, kevin)
  .collect(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(player -> BigDecimal.valueOf(player.getNumberOfWins())
    .divide(BigDecimal.valueOf(player.getNumberOfPlayed()), 2, RoundingMode.HALF_UP)))));
assertThat(myTreeSet).containsExactly(kai, eric, saajan, kevin);

As the test above shows, we’ve used the Comparator.comparing(Function keyExtractor) method to specify the comparable sort key. In this example, the keyExtractor function’s a lambda expression, which calculates a player’s win rate.

Also, if we run the test, it passes. So we’ve got the expected TreeSet.

4. Conclusion

In this article, we’ve discussed through examples how to collect elements in a Stream into a TreeSet by their natural ordering and custom comparators.