Finding Key associated with max Value in a Java Map

Question

What is the easiest way to get key associated with the max value in a map?

I believe that Collections.max(someMap) will return the max Key, when you want the key that corresponds to the max value.

score 174 · Answer 1 · edited May 14 '23 at 08:48

174

For completeness, here is a java-8 way of doing it

Cleanest way:

Collections.max(map.entrySet(), Map.Entry.comparingByValue()).getKey()

or

countMap.entrySet().stream().max((entry1, entry2) -> entry1.getValue() > entry2.getValue() ? 1 : -1).get().getKey();

or

Collections.max(countMap.entrySet(), (entry1, entry2) -> entry1.getValue() - entry2.getValue()).getKey();

or

Collections.max(countMap.entrySet(), Comparator.comparingInt(Map.Entry::getValue)).getKey();

edited May 14 '23 at 08:48

Rishabh Agarwal

2,374
1
21
27

answered Jan 18 '15 at 21:31

Hilikus

9,954
14
65
118

4

`(entry1, entry2) -> entry1.getValue() - entry2.getValue()` is more compact for the comparator. – JustABit May 16 '16 at 11:58
8

What to do if i want all keys that match the max value? – Mouna Jun 13 '16 at 11:45
8

Compact but hard to understand. – Lluis Martinez Sep 30 '16 at 12:01
1

You can also use the compare method provided by the Integer class `countMap.entrySet().stream().max((entry1, entry2) -> Integer.compare(entry1.getValue(), entry2.getValue())).get().getKey();` – Rui Filipe Pedro Dec 17 '16 at 18:24
4

Or you can use `Map.Entry.comparingByValue()` instead – Alexey Grigorev Feb 15 '17 at 22:05
Thanks Alexey - Now the third solution from Hilikus would become more consise like this `Collections.max(map.entrySet(), Map.Entry.comparingByValue()).getKey();`. – Tarun Oct 25 '22 at 13:58

Jon Skeet · Accepted Answer · 2023-05-14T11:42:06.560

160

Basically you'd need to iterate over the map's entry set, remembering both the "currently known maximum" and the key associated with it. (Or just the entry containing both, of course.)

For example:

Map.Entry<Foo, Bar> maxEntry = null;

for (Map.Entry<Foo, Bar> entry : map.entrySet())
{
    if (maxEntry == null || entry.getValue().compareTo(maxEntry.getValue()) > 0)
    {
        maxEntry = entry;
    }
}

edited May 14 '23 at 11:42

answered May 06 '11 at 12:10

Jon Skeet

1,421,763
867
9,128
9,194

46

+1: You can have more than one key with the same maximum value. This loop will give you the first one it finds. – Peter Lawrey May 06 '11 at 12:19
25

Changing > 0 to >= 0 will give you the last one it finds – Aaron J Lang Jan 03 '12 at 21:40
1

Would Java 8 streams usage help in simplifying this anymore? e.x: map.forEach((k,v) -> ... – zkarthik Dec 24 '14 at 17:04
3

@zkarthik: Using `max` with a custom comparator would probably be simpler. – Jon Skeet Dec 24 '14 at 18:01
I had to pass in a `Comparator cmp` parameter and compare values using `cmp.compare(entry.getValue(), maxEntry.getValue()) > 0)` – Atharva Shukla Mar 05 '22 at 15:01
1

@RishabhAgarwal: If you want to add additional options, please add a new answer rather than editing an existing one. – Jon Skeet May 14 '23 at 11:42

score 81 · Answer 3 · answered May 22 '16 at 13:04

81

A simple one liner using Java-8

Key key = Collections.max(map.entrySet(), Map.Entry.comparingByValue()).getKey();

answered May 22 '16 at 13:04

Sleiman Jneidi

22,907
14
56
77

3

@Samir https://docs.oracle.com/javase/7/docs/api/java/util/Map.Entry.html#getKey() – Sleiman Jneidi Sep 25 '16 at 20:50
@Samir, Please check you Java version. Sleiman Jneid has explicitly mentioned that it will work with Java 8 – Vaibs Sep 03 '17 at 14:08
1

@Vaibs I was using Java 8. It doesn't matter anymore, Hilikus' answer worked for me. – Samir Sep 05 '17 at 22:29
It works for me like this: `String max_key = Collections.max(map.entrySet(), Map.Entry.comparingByValue()).getKey();` – Timur Nurlygayanov Jan 11 '19 at 11:50
4

what if there are 2 such key that are max? how can it return an array of such key values? – Sophie Jul 04 '20 at 02:15
@Sophie maps don't allow duplicate keys. – Sleiman Jneidi Jul 04 '20 at 12:38
2

@SleimanJneidi The question doesn't ask about the duplicate keys. Consider a situation like this :- <1,8> <2,8> <5,4> <4,6> <6,7> There are 2 keys with maximum value 8. So it should return 1,2. – Sreekanth Karumanaghat Aug 27 '20 at 13:40
Nice, short and easy to understand – jjazzboss Oct 20 '21 at 20:44

score 71 · Answer 4 · edited Apr 24 '21 at 21:33

This code will print all the keys with maximum value

public class NewClass4 {
    public static void main(String[] args)
    {
        HashMap<Integer,Integer>map=new HashMap<Integer, Integer>();
        map.put(1, 50);
        map.put(2, 60);
        map.put(3, 30);
        map.put(4, 60);
        map.put(5, 60);
        int maxValueInMap=(Collections.max(map.values()));  // This will return max value in the HashMap
        for (Entry<Integer, Integer> entry : map.entrySet()) {  // Iterate through HashMap
            if (entry.getValue()==maxValueInMap) {
                System.out.println(entry.getKey());     // Print the key with max value
            }
        }

    }
}

it should be "Map.Entry entry: valmap.entrySet()" – Sophie Nov 28 '20 at 00:04 — Sophie, Nov 28 '20 at 00:04

score 11 · Answer 5 · answered May 23 '14 at 17:09

Here's how do do it directly (without an explicit extra loop) by defining the appropriate Comparator:

int keyOfMaxValue = Collections.max(
                        yourMap.entrySet(), 
                        new Comparator<Entry<Double,Integer>>(){
                            @Override
                            public int compare(Entry<Integer, Integer> o1, Entry<Integer, Integer> o2) {
                                return o1.getValue() > o2.getValue()? 1:-1;
                            }
                        }).getKey();

score 10 · Answer 6 · edited May 04 '21 at 07:51

1. Using Stream

public <K, V extends Comparable<V>> V maxUsingStreamAndLambda(Map<K, V> map) {
    Optional<Entry<K, V>> maxEntry = map.entrySet()
        .stream()
        .max((Entry<K, V> e1, Entry<K, V> e2) -> e1.getValue()
            .compareTo(e2.getValue())
        );
     
    return maxEntry.get().getKey();
}

2. Using Collections.max() with a Lambda Expression

    public <K, V extends Comparable<V>> V maxUsingCollectionsMaxAndLambda(Map<K, V> map) {
        Entry<K, V> maxEntry = Collections.max(map.entrySet(), (Entry<K, V> e1, Entry<K, V> e2) -> e1.getValue()
            .compareTo(e2.getValue()));
        return maxEntry.getKey();
    }

3. Using Stream with Method Reference

    public <K, V extends Comparable<V>> V maxUsingStreamAndMethodReference(Map<K, V> map) {
        Optional<Entry<K, V>> maxEntry = map.entrySet()
            .stream()
            .max(Map.Entry.comparingByValue());
        return maxEntry.get()
            .getKey();
    }

4. Using Collections.max()

    public <K, V extends Comparable<V>> V maxUsingCollectionsMax(Map<K, V> map) {
        Entry<K, V> maxEntry = Collections.max(map.entrySet(), new Comparator<Entry<K, V>>() {
            public int compare(Entry<K, V> e1, Entry<K, V> e2) {
                return e1.getValue()
                    .compareTo(e2.getValue());
            }
        });
        return maxEntry.getKey();
    }

5. Using Simple Iteration

public <K, V extends Comparable<V>> V maxUsingIteration(Map<K, V> map) {
    Map.Entry<K, V> maxEntry = null;
    for (Map.Entry<K, V> entry : map.entrySet()) {
        if (maxEntry == null || entry.getValue()
            .compareTo(maxEntry.getValue()) > 0) {
            maxEntry = entry;
        }
    }
    return maxEntry.getKey();
}

`3. Using Stream with Method Reference` is quite cool. – Sacky San Jun 16 '21 at 04:45 — Sacky San, Jun 16 '21 at 04:45

score 7 · Answer 7 · answered Nov 09 '16 at 22:24

7

An answer that returns an Optional since the map may have no max value if it is empty: map.entrySet().stream().max(Map.Entry.comparingByValue()).map(Map.Entry::getKey);

answered Nov 09 '16 at 22:24

Dave L.

43,907
11
63
62

score 7 · Answer 8 · answered Jun 22 '17 at 20:20

I have two methods, using this méthod to get the key with the max value:

 public static Entry<String, Integer> getMaxEntry(Map<String, Integer> map){        
    Entry<String, Integer> maxEntry = null;
    Integer max = Collections.max(map.values());

    for(Entry<String, Integer> entry : map.entrySet()) {
        Integer value = entry.getValue();
        if(null != value && max == value) {
            maxEntry = entry;
        }
    }
    return maxEntry;
}

As an example gettin the Entry with the max value using the method:

  Map.Entry<String, Integer> maxEntry =  getMaxEntry(map);

Using Java 8 we can get an object containing the max value:

Object maxEntry = Collections.max(map.entrySet(), Map.Entry.comparingByValue()).getKey();      

System.out.println("maxEntry = " + maxEntry);

score 7 · Answer 9 · answered Dec 11 '19 at 07:55

7

Simple to understand. In Below code, maxKey is the key which is holding the max value.

int maxKey = 0;
int maxValue = 0;
for(int i : birds.keySet())
{
    if(birds.get(i) > maxValue)
    {
        maxKey = i;
        maxValue = birds.get(i);
    }
}

answered Dec 11 '19 at 07:55

NickyPatel

503
4
11

Mariusz Szurgot · Answer 10 · 2017-06-13T12:02:26.333

Java 8 way to get all keys with max value.

Integer max = PROVIDED_MAP.entrySet()
            .stream()
            .max((entry1, entry2) -> entry1.getValue() > entry2.getValue() ? 1 : -1)
            .get()
            .getValue();

List listOfMax = PROVIDED_MAP.entrySet()
            .stream()
            .filter(entry -> entry.getValue() == max)
            .map(Map.Entry::getKey)
            .collect(Collectors.toList());

System.out.println(listOfMax);

Also you can parallelize it by using parallelStream() instead of stream()

score 4 · Answer 11 · answered Aug 30 '19 at 06:57

given map

HashMap abc = new HashMap<>();

get all map entries with a maximum of values.

you can use any of the below methods in the filter to get respective map entries for sets of minimum or maximum values

Collections.max(abc.values())
Collections.min(abc.values())
Collections.max(abc.keys())
Collections.max(abc.keys())

abc.entrySet().stream().filter(entry -> entry.getValue() == Collections.max(abc.values()))

if only want to get the keys for the filter map

abc.entrySet()
       .stream()
       .filter(entry -> entry.getValue() == Collections.max(abc.values()))
       .map(Map.Entry::getKey);

if you want to get the values for the filtered map

abc.entrySet()
      .stream()
      .filter(entry -> entry.getValue() == Collections.max(abc.values()))
      .map(Map.Entry::getvalue)

if you want to get all such keys in a list:

abc.entrySet()
  .stream()
  .filter(entry -> entry.getValue() == Collections.max(abc.values()))
  .map(Map.Entry::getKey)
  .collect(Collectors.toList())

if you want to get all such values in a list:

abc.entrySet()
  .stream()
  .filter(entry -> entry.getValue() == Collections.max(abc.values()))
  .map(Map.Entry::getvalue)
  .collect(Collectors.toList())

score 1 · Answer 12 · answered Nov 18 '15 at 17:24

Is this solution ok?

int[] a = { 1, 2, 3, 4, 5, 6, 7, 7, 7, 7 };
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i : a) {
Integer count = map.get(i);
map.put(i, count != null ? count + 1 : 0);
}
Integer max = Collections.max(map.keySet());
System.out.println(max);
System.out.println(map);

score 1 · Answer 13 · answered Jun 04 '19 at 20:44

1

int maxValue = 0;
int mKey = 0;
for(Integer key: map.keySet()){
    if(map.get(key) > maxValue){
        maxValue = map.get(key);
        mKey = key;
    }
}
System.out.println("Max Value " + maxValue + " is associated with " + mKey + " key");

answered Jun 04 '19 at 20:44

Abdullah Uzundere

11
1

2

Code-only answers are generally frowned upon on this forum. Please edit your answer to include an explanation of your code. How does it solve OP's problem? – mypetlion Jun 04 '19 at 20:50

score 1 · Answer 14 · answered Jul 26 '19 at 11:25

Majority Element/ max element in the map :

public class Main {
     public static void main(String[] args) {
     int[] a = {1,3,4,3,4,3,2,3,3,3,3,3};
     List<Integer> list = Arrays.stream(a).boxed().collect(Collectors.toList());
     Map<Integer, Long> map = list.parallelStream()
             .collect(Collectors.groupingBy(Function.identity(),Collectors.counting()));
     System.out.println("Map => " + map);
     //{1=1, 2=1, 3=8, 4=2}
     map.entrySet()
     .stream()
     .max(Comparator.comparing(Entry::getValue))//compare the values and get the maximum value
     .map(Entry::getKey)// get the key appearing maximum number of times
     .ifPresentOrElse(System.out::println,() -> new RuntimeException("no such thing"));

     /*
      * OUTPUT : Map => {1=1, 2=1, 3=8, 4=2} 
      * 3
      */
     // or in  this way 
     System.out.println(".............");
     Integer maxAppearedElement = map.entrySet()
             .parallelStream()
             .max(Comparator.comparing(Entry::getValue))
             .map(Entry::getKey)
             .get();
     System.out.println(maxAppearedElement);

     } 
}

score 0 · Answer 15 · answered Sep 20 '15 at 02:44

For my project, I used a slightly modified version of Jon's and Fathah's solution. In the case of multiple entries with the same value, it returns the last entry it finds:

public static Entry<String, Integer> getMaxEntry(Map<String, Integer> map) {        
    Entry<String, Integer> maxEntry = null;
    Integer max = Collections.max(map.values());

    for(Entry<String, Integer> entry : map.entrySet()) {
        Integer value = entry.getValue();

        if(null != value && max == value) {
            maxEntry = entry;
        }
    }

    return maxEntry;
}

Diego Marin Santos · Answer 16 · 2021-02-02T21:56:49.110

This is going to return the keys with max value in a Map<Integer, Integer>

public Set<Integer> getMaxKeys(Map<Integer, Integer> map) { 

        if (map.isEmpty()) {
            return Collections.emptySet();
        }

        return map
        .entrySet()
        .stream()
        .collect(
            groupingBy(
                Map.Entry::getValue, TreeMap::new, mapping(Map.Entry::getKey, toSet())
            )
         )
         .lastEntry()
         .getValue();
    }

score 0 · Answer 17 · answered May 10 '22 at 12:31

0

Kotlin:

val key = map.toList().groupingBy { it }.eachCount().maxByOrNull { it.value }?.key

answered May 10 '22 at 12:31

Dr.jacky

3,341
6
53
91

score 0 · Answer 18 · answered May 10 '22 at 16:02

0

    int max = 0;
// here m is a HashMap<String, Integer>
    for(Map.Entry<String,Integer> entry : m.entrySet()){

       if(entry.getValue() > max){
          max = entry.getValue();              
       }
    }

answered May 10 '22 at 16:02

Imran Sefat

528
4
6

Your answer doesn't show how the key for the corresponding max value is retrieved. – Abhijith Ravindran Jun 21 '22 at 01:26

Parnab Sanyal · Answer 19 · 2016-04-25T08:42:47.943

you can do like that

HashMap<Integer,Integer> hm = new HashMap<Integer,Integer>();
hm.put(1,10);
hm.put(2,45);
hm.put(3,100);
Iterator<Integer> it = hm.keySet().iterator();
Integer fk = it.next();
Integer max = hm.get(fk);
while(it.hasNext()) {
    Integer k = it.next();
    Integer val = hm.get(k);
    if (val > max){
         max = val;
         fk=k;
    }
}
System.out.println("Max Value "+max+" is associated with "+fk+" key");

score -2 · Answer 20 · edited Jul 19 '21 at 23:05

-2

The simplest way is:

Collections.max(hmap.values());

edited Jul 19 '21 at 23:05

Josep Valls

5,483
2
33
67

answered Jul 19 '21 at 05:56

Sophie

77
1
2
8

This would return the largest _value_, rather than the largest _key_ associated to it – jmm Feb 01 '22 at 23:02

Finding Key associated with max Value in a Java Map

20 Answers20

Linked

Related