How to get all objects having the same max value with Java streams?

Question

I have players which have points. I want to get all the players who share the max amount of points using a stream and a filter.

public class Player {
    private int points; // Getter omitted
}

I can do this by first getting the player with the most points, and the filtering all players that have the same amount.

Player topPlayer = players.stream().max(Comparator.comparing(Player::getPoints)).orElse(null);

players.stream().filter(p -> p.getPoints() == topPlayer.getPoints()).collect(Collectors.toList());

Can this be done with a single predicate / single line ?

Eugene · Accepted Answer · 2019-01-24T13:18:11.477

10

You could collect to a TreeMap first and only get the last entry (where the max is)

players.stream()
       .collect(Collectors.groupingBy(
           Player::getPoints,
           TreeMap::new,
           Collectors.toList()
       ))
       .lastEntry()
       .getValue();

edited Jan 24 '19 at 13:18

answered Jan 24 '19 at 13:01

Eugene

117,005
15
201
306

2

Though the OP's original solution is more efficient in terms of complexity (O(n) vs. your O(nlogn)). – Eran Jan 24 '19 at 13:03
1

@Eran agreed. also the additional space... – Eugene Jan 24 '19 at 13:06
It might be less efficient, but I could make good use of that TreeMap, because I must repeat my code for each group of points, actually. – Yotus Jan 24 '19 at 13:08
I just tried your solution, but getLastEntry() is not public in TreeMap, is it ? Or am I missing something ? – Yotus Jan 24 '19 at 13:16
2

@Yotus my bad, it's actually `lastEntry` – Eugene Jan 24 '19 at 13:18
You don't need to pass `Collectors.toList()`. – shmosel Jan 24 '19 at 15:19
1

@shmosel I think you do – Eugene Jan 24 '19 at 15:20
You can do it in O(n): `players.stream() .collect(Collectors.collectingAndThen(Collectors.groupingBy(Player::getPoints), m -> Collections.max(m.entrySet(), Map.Entry.comparingByKey()))) .getValue()` – Holger Jan 28 '19 at 11:29

TongChen · Answer 2 · 2019-01-24T15:16:30.320

6

First group by the points and get a Map result,then find the max key in map. Time cost will be O(n):

List<Player> players = new ArrayList<>();
players.stream().collect(Collectors.groupingBy(Player::getPoints))
        .entrySet().stream()
        .max(Map.Entry.comparingByKey())
        .ifPresent(System.out::println);

edited Jan 24 '19 at 15:16

answered Jan 24 '19 at 14:58

TongChen

1,414
1
11
21

you can simplify this with `Map::comparingByKey` btw – Eugene Jan 24 '19 at 15:08
@Eugene thanks very much – TongChen Jan 24 '19 at 15:15

Lii · Answer 3 · 2019-01-24T18:47:47.327

Here is a version that uses a custom collector. It is HUGE and ugly and complicated, but it runs in O(n), only makes one pass over the data, and requires little extra space.

List<Player> highest = players.stream().collect(ArrayList::new, 
    (list, player) -> {
        if (list.isEmpty() || list.get(0).getPoints() == player.getPoints()) {
            list.add(player);
        } else if (list.get(0).getPoints() < player.getPoints()) {
            list.clear();
            list.add(player);
        }
    },
    (l1, l2) -> {
        if (l1.isEmpty()) {
            l1.addAll(l2);
        } else if (!l2.isEmpty()) {
            int cmp = Integer.compare(l1.get(0).getPoints(), l2.get(0).getPoints());
            if (cmp < 0) {
                l1.clear();
                l1.addAll(l2);
            } else if (cmp == 0) {
                l1.addAll(l2);
            }
        }
    });

The proof that the accumulator and combiner are associative is left as an exercise to the reader.

EDIT: I tried to write a prettier combiner. I managed to write a shorter and weirder. I believe it is the same as the one above:

(l1, l2) -> {
    int cmp = l1.stream().findAny().flatMap(p1 -> l2.stream().findAny().map(
            p2 -> Integer.compare(p1.getPoints(), p2.getPoints()))).orElse(0);
    if (cmp < 0) l1.clear();
    if (cmp <= 0) l1.addAll(l2);
}

How to get all objects having the same max value with Java streams?

3 Answers3

Linked

Related