Znajdowanie klucza związanego z maksymalną wartością w mapie Java

137

Jaki jest najłatwiejszy sposób na uzyskanie klucza związanego z maksymalną wartością na mapie?

Uważam, że Collections.max (someMap) zwróci klucz maksymalny, jeśli chcesz, aby klucz odpowiadał wartości maksymalnej.

Ben B.
źródło

Odpowiedzi:

136

Zasadniczo należałoby iterować po zestawie wpisów mapy, pamiętając zarówno „aktualnie znane maksimum”, jak i skojarzony z nim klucz. (Lub oczywiście tylko wpis zawierający oba).

Na przykład:

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;
    }
}
Jon Skeet
źródło
40
+1: Możesz mieć więcej niż jeden klucz o tej samej wartości maksymalnej. Ta pętla da ci pierwszą, jaką znajdzie.
Peter Lawrey
21
Zmiana> 0 na> = 0 da ci ostatni znaleziony
Aaron J Lang
1
Czy użycie strumieni Java 8 pomogłoby już w uproszczeniu tego? np. map.forEach ((k, v) -> ...
zkarthik
3
@zkarthik: Korzystanie maxz niestandardowego komparatora byłoby prawdopodobnie prostsze.
Jon Skeet
112

Aby uzyskać kompletność, tutaj jest sposób na zrobienie tego

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

lub

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

lub

Collections.max(countMap.entrySet(), Comparator.comparingInt(Map.Entry::getValue)).getKey();
Hilikus
źródło
3
(entry1, entry2) -> entry1.getValue() - entry2.getValue()jest bardziej zwarty dla komparatora.
JustABit
5
Co zrobić, jeśli chcę, aby wszystkie klucze pasowały do ​​wartości maksymalnej?
Mouna
4
Kompaktowy, ale trudny do zrozumienia.
Lluis Martinez
1
Możesz także skorzystać z metody porównywania udostępnionej przez klasę IntegercountMap.entrySet().stream().max((entry1, entry2) -> Integer.compare(entry1.getValue(), entry2.getValue())).get().getKey();
Rui Filipe Pedro
3
Lub możesz użyć Map.Entry.comparingByValue()zamiast tego
Alexey Grigorev
55

Ten kod wypisze wszystkie klucze z maksymalną wartością

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()) {  // Itrate through hashmap
            if (entry.getValue()==maxValueInMap) {
                System.out.println(entry.getKey());     // Print the key with max value
            }
        }

    }
}
Fathah Rehman P.
źródło
47

Prosty jeden liner wykorzystujący Java-8

Key key = Collections.max(map.entrySet(), Map.Entry.comparingByValue()).getKey();
Sleiman Jneidi
źródło
3
Najbardziej eleganckie i zminimalizowane rozwiązanie. Dzięki
Daniel Hári
@Samir, sprawdź wersję Java. Sleiman Jneid wyraźnie wspomniał, że będzie działać z Javą 8
Vaibs
@Vaibs Używałem Javy 8. To już nie ma znaczenia, odpowiedź Hilikusa zadziałała dla mnie.
Samir
U mnie to działa tak: String max_key = Collections.max(map.entrySet(), Map.Entry.comparingByValue()).getKey();
Timur Nurlygayanov
8

Oto jak zrobić to bezpośrednio (bez wyraźnej dodatkowej pętli), definiując odpowiednie 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();
Amir
źródło
6

Odpowiedź, która zwraca Opcjonalne, ponieważ mapa może nie mieć wartości maksymalnej, jeśli jest pusta: map.entrySet().stream().max(Map.Entry.comparingByValue()).map(Map.Entry::getKey);

Dave L.
źródło
4

Java 8 sposób na uzyskanie wszystkich kluczy o maksymalnej wartości.

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);

Możesz również zrównoleglać go, używając parallelStream()zamiaststream()

Mariusz Szurgot
źródło
4

Mam dwie metody, używając tej metody, aby uzyskać klucz o maksymalnej wartości:

 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;
}

Jako przykład pobierz Entry z maksymalną wartością za pomocą metody:

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

Korzystając z Javy 8 możemy otrzymać obiekt zawierający maksymalną wartość:

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

System.out.println("maxEntry = " + maxEntry);
Jorgesys
źródło
Wersja Java 8 jest prosta, ale skuteczna!
Dobra
3

1. Korzystanie z usługi 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. Używanie Collections.max () z wyrażeniem lambda

    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. Używanie Stream z odniesieniem do metody

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

4. Korzystanie z 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. Korzystanie z prostej iteracji

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();
}
Manas Ranjan Mahapatra
źródło
Przejął Baldung.com baeldung.com/java-find-map-max
Sir Montes
2

Proste do zrozumienia. W poniższym kodzie maxKey jest kluczem, który utrzymuje maksymalną wartość.

int maxKey = 0;
int maxValue = 0;
for(int i : birds.keySet())
{
    if(birds.get(i) > maxValue)
    {
        maxKey = i;
        maxValue = birds.get(i);
    }
}
umeshfadadu
źródło
1

Czy to rozwiązanie jest w porządku?

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);
Danilo
źródło
1

Element większościowy / maksymalny na mapie:

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);

     } 
}
Soudipta Dutta
źródło
1

podana mapa

HashMap abc = new HashMap <> ();

pobierz wszystkie wpisy mapy z maksymalną wartością.

możesz użyć dowolnej z poniższych metod w filtrze, aby uzyskać odpowiednie wpisy mapy dla zestawów wartości minimalnych lub maksymalnych

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()))

jeśli tylko chcesz zdobyć klucze do mapy filtrów

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

jeśli chcesz uzyskać wartości dla przefiltrowanej mapy

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

jeśli chcesz mieć wszystkie takie klucze na liście:

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

jeśli chcesz uzyskać wszystkie takie wartości na liście:

abc.entrySet()
  .stream()
  .filter(entry -> entry.getValue() == Collections.max(abc.values()))
  .map(Map.Entry::getvalue)
  .collect(Collectors.toList())
Arpan Saini
źródło
0

W moim projekcie użyłem nieco zmodyfikowanej wersji rozwiązania Jona i Fathah. W przypadku wielu wpisów o tej samej wartości, zwraca ostatni znaleziony wpis:

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;
}
srebro
źródło
0
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");
Abdullah Uzundere
źródło
2
Odpowiedzi zawierające tylko kod są generalnie mile widziane na tym forum. Zmień swoją odpowiedź, tak aby zawierała wyjaśnienie kodu. Jak rozwiązuje problem OP?
mypetlion
-2

możesz to zrobić

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");
Parnab Sanyal
źródło