Finding all max values in (tree)map with streams and lambda in java

So I have to find the max value(s) in a map in java with streams and lambda. Finding one max value is not a problem, but how can I find multiple?
Example:
Treemap<String, Integer> with elements "e" = 2, "i" = 1, "a" = 2,
My current solution gives me "a" = 2, but I want "a" = 2, "e" = 2

My code:

Map<String, Integer> frequencies = new Treemap<>();
frequencies.put("e", 2);//I don't put the values in like this but it'll do to test
frequencies.put("i", 1);
frequencies.put("a", 2);
Optional<Map.Entry<String, Integer>> maxEntry = frequencies.entrySet().stream()
        .max(Map.Entry.comparingByValue());//frequencies is the TreeMap<String, Integer>
//I know this only searches one max value, here's my other attempt:
try (Stream<Map.Entry<String, Integer>> stream = frequencies.entrySet().stream()) {
      stream
          .sorted(Map.Entry.comparingByValue())
          .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (k, v) -> k, LinkedHashMap::new));
//I don't know what to do here, I somehow would have to get the result into a new list, but it still only returns one result
    }

Please let me know if im doing anything wrong.

> So I have to find the max value(s) in a map in java with streams and lambda.

Here is one way to do it without a TreeMap. It does a frequency count of containing Entries.

Map<String, Integer> map = Map.of("z", -1, "b", 0, "r", -2,
"s", 0, "j", 1, "a", 2, "i", 1, "e", 2);
Optional<Entry<Integer, List<Entry<String,Integer>>>> opt = map.entrySet()
.stream()
.collect(Collectors.groupingBy(Entry::getValue))
.entrySet().stream().max(Entry.comparingByKey());
System.out.println(opt.isPresent() ? opt.get().getValue() : "Empty List");

Prints

[a=2, e=2]

And just for fun you can bypass the initial map and create a stream of entries. In reality, when you create your intitial Map you are creating Entry objects so no additional map overhead is involved here.

		
Builder<Entry<String, Integer>> entryStream = Stream.builder();
entryStream.add(Map.entry("b", 0));
entryStream.add(Map.entry("r", -2));
entryStream.add(Map.entry("s", 0));
entryStream.add(Map.entry("j", 1));
entryStream.add(Map.entry("a", 2));
entryStream.add(Map.entry("i", 1));
entryStream.add(Map.entry("e", 2));

At this point, it's the same as before except the stream is ready to invoke.

Optional<Entry<Integer, List<Entry<String, Integer>>>> opt =
entryStream.build()
.collect(Collectors
.groupingBy(Entry::getValue))
.entrySet().stream()
.max(Entry.comparingByKey());
System.out.println(opt.isPresent() ? opt.get().getValue() :
"Empty List");

Prints as before

[a=2, e=2]
</details>
# 答案2
**得分**: 1
首先，找到最大频率：
```java
Optional<Integer> maxFreqOptional = frequencies.values()
.stream()
.max(Comparator.naturalOrder());

然后，您可以收集所有具有此频率的条目作为值：

Integer maxFreq = maxFreqOptional.get(); // 首先检查是否为空
List<String> mostFrequent = frequencies.entrySet()
    .stream()
    .filter(entry -> entry.getValue().equals(maxFreq))
    .map(Map.Entry<String, Integer>::getKey)
    .collect(Collectors.toList());

如果您需要任何进一步的帮助，请告诉我。

Optional<Integer> maxFreqOptional = frequencies.values()
.stream()
.max(Comparator.naturalOrder());

Integer maxFreq = maxFreqOptional.get(); // check if it's empty first
List<String> mostFrequent = frequencies.entrySet()
.stream()
.filter(entry -> entry.getValue().equals(maxFreq))
.map(Map.Entry<String, Integer>::getKey)
.collect(Collectors.toList());

答案3

得分: 1

收集输入流至TreeMap，使用值（频率）作为键，原始键作为值。因此，使用级联的groupingBy。然后取具有最大键的条目：

TreeMap<Integer, List<String>> map = frequencies.entrySet().stream()
    .collect(Collectors.groupingBy(
        Map.Entry<String, Integer>::getValue, TreeMap::new, Collectors.toList()
    ));
Map.Entry<Integer, List<String>> largest = map.lastEntry();

注意：如果您的数据集很大，并且希望避免构建这个反向映射，您可能更喜欢其中一种建议的解决方案，它们两次迭代映射：一次用于找到最大频率，然后再次用于找到所有对应的条目。

TreeMap<Integer, List<String>> map = frequencies.entrySet().stream()
.collect(Collectors.groupingBy(
Map.Entry<String, Integer>::getValue, TreeMap::new, Collectors.toList()
));
Map.Entry<Integer, List<String>> largest = map.lastEntry();

答案4

得分: 1

你可以根据maxEntry的值进行筛选，以获取所有最大值的Map.Entry。

List<Map.Entry<String, Integer>> res = frequencies.entrySet().stream()
                                     .filter(e -> e.getValue().equals(maxEntry.get().getValue()))
                                     .collect(Collectors.toList());

在线演示在这里

输出结果：[a=2, e=2]

List<Map.Entry<String, Integer>> res = frequencies.entrySet().stream()
.filter(e -> e.getValue().equals(maxEntry.get().getValue()))
.collect(Collectors.toList());

答案5

得分: 0

以下是翻译好的部分：

"As you only need the entries that match the max value, there's no gain in grouping all the entries of the map in a reverse map. You only need to discard all entries whose value doesn't match the max value.

Here's a succinct way to do it with lambdas:

Integer max = frequencies.isEmpty() ?
Integer.MIN_VALUE :
Collections.max(frequencies.values());

List result = new ArrayList<>();
frequencies.forEach((k, v) -> { if (v.equals(max)) result.add(k); });

So, in 'max' you have the max value, while in 'result' you have the keys that match the max value. This algorithm's time complexity is 'O(n)' worst case, unlike the algorithms that group entries, which are all 'O(nlogn)'.

The streams equivalent version is more verbose:

Integer max = frequencies.values().stream()
.max(Comparator.naturalOrder())
.orElse(Integer.MIN_VALUE);

List result = frequencies.entrySet().stream()
.filter(e -> e.getValue().equals(max))
.map(Map.Entry::getKey)
.collect(Collectors.toList());"

Integer max = frequencies.isEmpty() ? 
Integer.MIN_VALUE :
Collections.max(frequencies.values());
List<String> result = new ArrayList<>();
frequencies.forEach((k, v) -> { if (v.equals(max)) result.add(k); });

Integer max = frequencies.values().stream()
.max(Comparator.naturalOrder())
.orElse(Integer.MIN_VALUE);
List<String> result = frequencies.entrySet().stream()
.filter(e -> e.getValue().equals(max))
.map(Map.Entry::getKey)
.collect(Collectors.toList());