जावा मैप में अधिकतम मान के साथ संबंधित कुंजी खोजना

Question

किसी मानचित्र में अधिकतम मान से संबद्ध कुंजी प्राप्त करने का सबसे आसान तरीका क्या है?

मेरा मानना ​​है कि Collections.max (someMap) अधिकतम कुंजी लौटाएगा, जब आप उस कुंजी को चाहते हैं जो अधिकतम मूल्य से मेल खाती है।

Answer 1

मूल रूप से आपको "वर्तमान में अधिकतम ज्ञात" और इसके साथ जुड़ी कुंजी दोनों को याद करते हुए, नक्शे के प्रवेश सेट पर पुनरावृत्त करना होगा। (या सिर्फ प्रविष्टि जिसमें दोनों हैं, निश्चित रूप से।)

उदाहरण के लिए:

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

Comments

+1: आप एक ही अधिकतम मान के साथ एक से अधिक कुंजी रख सकते हैं। यह लूप आपको वह पहला मिलेगा जो उसे मिलता है।

— पीटर लॉरी

> 0 से> = 0 को बदलने से आपको वह अंतिम मिल जाएगा

— एरोन जे लैंग

क्या जावा 8 स्ट्रीम उपयोग अब इसे सरल बनाने में मदद करेगा? ex: map.forEach ((k, v) -> ...

— zkarthik

@ ज़कार्तिक: maxएक कस्टम तुलनित्र के साथ प्रयोग करना शायद सरल होगा।

— जॉन स्कीट

Answer 2

पूर्णता के लिए, यहाँ एक है जावा-8 इसे करने का तरीका

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

या

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

या

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

Comments

(entry1, entry2) -> entry1.getValue() - entry2.getValue()तुलनित्र के लिए अधिक कॉम्पैक्ट है।

— जस्टबेट

अगर मुझे अधिकतम मूल्य से मेल खाने वाली सभी चाबियां चाहिए तो क्या करें?

— मौना

कॉम्पैक्ट लेकिन समझने में कठिन।

— लुलिस मार्टिनेज

आप इंटेगर वर्ग द्वारा प्रदान की गई तुलना विधि का उपयोग भी कर सकते हैंcountMap.entrySet().stream().max((entry1, entry2) -> Integer.compare(entry1.getValue(), entry2.getValue())).get().getKey();

— रुई फिलीप पेड्रो

या आप Map.Entry.comparingByValue()इसके बजाय उपयोग कर सकते हैं

— एलेक्सी ग्रिगोरोव

Answer 3

यह कोड सभी मानों को अधिकतम मूल्य के साथ प्रिंट करेगा

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

    }
}

Answer 4

जावा -8 का उपयोग करते हुए एक साधारण लाइनर

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

Comments

@Samir docs.oracle.com/javase/7/docs/api/java/util/…

— '20:

सबसे सुंदर और कम से कम समाधान। धन्यवाद

— डैनियल हैरी

@Samir, कृपया जावा संस्करण की जाँच करें। स्लीमैन जानिद ने स्पष्ट रूप से उल्लेख किया है कि यह

— वाइब्स

@Vaibs मैं जावा 8 का उपयोग कर रहा था। यह अब और मायने नहीं रखता है, हिल्कियस के जवाब ने मेरे लिए काम किया।

— समीर

यह मेरे लिए इस तरह काम करता है: String max_key = Collections.max(map.entrySet(), Map.Entry.comparingByValue()).getKey();

— तैमूर नुरलीगानोव

Answer 5

यहां बताया गया है कि इसे सीधे कैसे करें (स्पष्ट अतिरिक्त लूप के बिना) उपयुक्त परिभाषित करके 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();

Answer 6

एक उत्तर जो मानचित्र के बाद से एक वैकल्पिक लौटाता है, यदि रिक्त है तो इसका कोई अधिकतम मूल्य नहीं हो सकता है: map.entrySet().stream().max(Map.Entry.comparingByValue()).map(Map.Entry::getKey);

Answer 7

अधिकतम मूल्य के साथ सभी कुंजी प्राप्त करने के लिए जावा 8 तरीका।

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

इसके अलावा आप इसके parallelStream()बजाय का उपयोग करके इसे समानांतर कर सकते हैंstream()

Answer 8

मेरे पास दो विधियाँ हैं, इस méthod का उपयोग करके अधिकतम मूल्य के साथ कुंजी प्राप्त करें:

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

एक उदाहरण के रूप में विधि का उपयोग करके अधिकतम मूल्य के साथ प्रविष्टि प्राप्त करें:

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

---

Java 8 का उपयोग करके हम अधिकतम मूल्य वाली एक वस्तु प्राप्त कर सकते हैं:

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

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

Comments

जावा 8 संस्करण सरल लेकिन प्रभावी है! अच्छा काम

— कैटलिफ्ट्स

Answer 9

1. स्ट्रीम का उपयोग करना

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. लेम्ब्डा एक्सप्रेशन के साथ कलेक्शन्स.मैक्स () का उपयोग करना

    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. विधि संदर्भ के साथ स्ट्रीम का उपयोग करना

    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. 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. सिंपल इटरेशन का उपयोग करना

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

Comments

बाल्डुंग.कॉम baeldung.com/java-find-map-max

— सर मोंटेस

Answer 10

समझने में सरल। नीचे दिए गए कोड में, maxKey वह कुंजी है जो अधिकतम मूल्य रखती है।

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

Answer 11

क्या यह समाधान ठीक है?

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

Answer 12

मानचित्र में अधिकांश तत्व / अधिकतम तत्व:

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

     } 
}

Answer 13

नक्शा दिया गया

HashMap abc = नया HashMap <> ();

अधिकतम मूल्यों के साथ सभी मानचित्र प्रविष्टियां प्राप्त करें।

आप न्यूनतम या अधिकतम मानों के सेट के लिए संबंधित मानचित्र प्रविष्टियाँ प्राप्त करने के लिए फ़िल्टर में नीचे दिए गए किसी भी तरीके का उपयोग कर सकते हैं

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

यदि केवल फ़िल्टर मानचित्र की कुंजी प्राप्त करना चाहते हैं

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

यदि आप फ़िल्टर किए गए मानचित्र के लिए मान प्राप्त करना चाहते हैं

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

यदि आप किसी सूची में ऐसी सभी कुंजी प्राप्त करना चाहते हैं:

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

यदि आप किसी सूची में ऐसे सभी मान प्राप्त करना चाहते हैं:

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

Answer 14

अपने प्रोजेक्ट के लिए, मैंने जॉन के और फ़तह के समाधान का थोड़ा संशोधित संस्करण इस्तेमाल किया। एक ही मूल्य के साथ कई प्रविष्टियों के मामले में, यह वह अंतिम प्रविष्टि देता है जो यह पाता है:

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

Answer 15

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

Comments

कोड-ओनली उत्तर आमतौर पर इस फोरम पर दिए जाते हैं। अपने कोड की व्याख्या शामिल करने के लिए कृपया अपना उत्तर संपादित करें। यह ओपी की समस्या को कैसे हल करता है?

— मैपिलेयन

Answer 16

आप ऐसा कर सकते हैं

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