Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

Generic Top

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

>> CHECK OUT THE COURSE

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.

As always, the complete source code for the examples is available over on GitHub.

Generic bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

>> CHECK OUT THE COURSE
Generic footer banner
Comments are closed on this article!