मूल्य

Question

द्वारा क्रमशः आदेश हैशैप ऑर्डर करें मेरे पास HashMap<Object, Student> है जहां ऑब्जेक्ट छात्र की आईडी है, और छात्र छात्र से एक वस्तु है।

मैं छात्र नाम, student->getName() द्वारा हैश मैप का सहारा कैसे ले सकता हूं?

Answer 1

हैशमैप्स आंतरिक रूप से अनियंत्रित हैं और क्रमबद्ध नहीं किए जा सकते हैं।

इसके बजाय, आप SortedMap कार्यान्वयन का उपयोग कर सकते हैं, जैसे TreeMap।
हालांकि, यहां तक ​​कि एक क्रमबद्ध नक्शा केवल इसकी चाबियों द्वारा क्रमबद्ध कर सकता है।

यदि आप मानों से क्रमबद्ध करना चाहते हैं, तो आपको उन्हें एक क्रमबद्ध सूची में कॉपी करने की आवश्यकता होगी।

Answer 2

हैशमैप्स को उनके मूल्यों से क्रमबद्ध नहीं किया जा सकता है। एक मानचित्र को कुंजी के आधार पर निरंतर समय लुकअप के लिए डिज़ाइन किया गया है, इसलिए मूल्यों के अनुसार आदेश आवश्यक नहीं होना चाहिए। यदि आपको नाम से सॉर्ट करने की आवश्यकता है, तो मैं SortedSet का उपयोग करने और नामों से संबंधित एक तुलनित्र बनाने का सुझाव देता हूं।

class StudentComparator implements Comparator<Student> { 
    int compare(Student s1, Student s2) { 
     return s1.getName().compareTo(s2.getName()); 
    } 
} 

यदि आपको निरंतर समय लुकअप और सॉर्ट-बाय-वैल्यू सेट दोनों की आवश्यकता है, तो आपको नक्शा और एक सेट बनाए रखने की आवश्यकता हो सकती है।

Answer 3

मानचित्रों द्वारा मूल्यों का आदेश नहीं दिया जा सकता है। आप यह कर सकते हैं, हालांकि:

Collection<Student> students = map.values(); 

Collection.sort(new ArrayList<Student>(students)), new Comparator<Student>() { 
    public int compare(Student s1, Student s2) { 
     return s1.getName().compareTo(s2.getName()); 
    } 
}); 

मान लीजिए कि आपको मूल्यों पर पुन: प्रयास करने की आवश्यकता है। (आप इसे और क्यों आदेश देना चाहते हैं?)

शुभकामनाएं।

Answer 4

मैं निश्चित रूप से एक नई कक्षा का उपयोग करूंगा जो कुंजी और ऑब्जेक्ट को स्टोर करेगा।

फिर आप इस वर्ग के रूप में मानचित्र के प्रत्येक तत्व को एक ArrayList में डाल सकते हैं, और अंत में ArrayList को सॉर्ट करने के लिए एक तुलनित्र का उपयोग कर सकते हैं, इसके बाद आप बस एक नया मानचित्र बना सकते हैं।

Map<Object, Student> valueMap = new LinkedHashMap<String, String>(); 
List<Student> pairValueList = new ArrayList<PairValue>(); 

PairValue p; 
for (Map.Entry<Object, Student> entry : map.entrySet()) { 
    Object key = entry.getKey(); 
    Student value = entry.getValue();   
    p = new PairValue(key, value); 
    pairValueList.add(p); 
} 

Collections.sort(pairValueList, new Comparator<PairValue>() { 
    @Override 
    public int compare(PairValue c1, PairValue c2) { 
    return c1.getLabel().compareTo(c2.getLabel()); 
    } 
}); 

for (PairValue pv : pairValueList) { 
    valueMap.put(pv.getValue(), pv.getStudent()); 
} 

PairValue वर्ग

class PairValue {  

    private Object value;  
    private Student student; 

    public PairValue(Object value, String student) { 
    this.value = value; 
    this.student= student; 
    } 

    public String getValue() { 
    return value; 
    } 

    public String getStudent() { 
    return student; 
    }  
} 

तरह से मैं कुछ इसी तरह की समस्या मैंने पहले भी था हल यही: कोड कुछ इस तरह हो जाएगा। कृपया ध्यान दें कि लौटाए गए मानचित्र कार्यान्वयन को LinkedHashMap होना चाहिए।

Answer 5

हो सकता है कि आप हैश मैप को सॉर्ट करने में सक्षम न हों, लेकिन आप निश्चित रूप से ऐसा कुछ कर सकते हैं जो समान प्रभाव प्रदान करता हो। मैं Javarevisited ब्लॉग पर पोस्ट किए गए उत्कृष्ट कोड का उपयोग करके इंटीजर के अवरोही मूल्य से अपने हैश मैप < स्ट्रिंग, इंटीजर > को सॉर्ट करने में सक्षम था। इसी सिद्धांत एक HashMap < स्ट्रिंग के लिए लागू होता है, स्ट्रिंग > वस्तु:

/* 
* Java method to sort Map in Java by value e.g. HashMap or Hashtable 
* throw NullPointerException if Map contains null values 
* It also sort values even if they are duplicates 
*/ 
public static <K extends Comparable,V extends Comparable> Map<K,V> sortByValues(Map<K,V> map){ 
    List<Map.Entry<K,V>> entries = new LinkedList<Map.Entry<K,V>>(map.entrySet()); 

    Collections.sort(entries, new Comparator<Map.Entry<K,V>>() { 

     @Override 
     public int compare(Entry<K, V> o1, Entry<K, V> o2) { 
      return o1.getValue().compareTo(o2.getValue()); 
      // to compare alphabetically case insensitive return this instead 
      // o1.getValue().toString().compareToIgnoreCase(o2.getValue().toString()); 
     } 
    }); 

    //LinkedHashMap will keep the keys in the order they are inserted 
    //which is currently sorted on natural ordering 
    Map<K,V> sortedMap = new LinkedHashMap<K,V>(); 

    for(Map.Entry<K,V> entry: entries){ 
     sortedMap.put(entry.getKey(), entry.getValue()); 
    } 

    return sortedMap; 
} 

इस विधि कॉल करने के लिए, मैं का उपयोग करें:

Map<String, Integer> sorted = sortByValues(myOriginalHashMapObject); 

और अधिक पढ़ें: http://javarevisited.blogspot.com/2012/12/how-to-sort-hashmap-java-by-key-and-value.html#ixzz2akXStsGj