कुंजी के आधार पर छंटनी हैशमैप

Question

मेरे पास जावा में निम्नलिखित हैशमप है:

{B046 = 0.0, A061 = 3.0, A071 = 0.0, B085 = 0.0, B075 = 3.0, B076 = 9.0, B086 = 3.0, B095 = 0.0, B096 = 0.0, A052 = 0.0, B066 = 0.0, B056 = 9.0, B065 = 0.0, B055 = 9.0}

मुझे हैशमैप को क्रमबद्ध करने के बारे में कैसे जाना चाहिए ताकि वर्णमाला, उसके बाद संख्यात्मक आंकड़ों को ध्यान में रखा जाए?

परिणामी हैशमैप इस तरह दिखना चाहिए:

{A052 = 0.0, A061 = ३.०, ए ० 0.0१ = ०.०, ०४६ = ०.०, बी ०५ = १ ९९ ०, बी ० ५६ = ० ९, बी ०६६ = ०.०, बी ०६६ = ०.०, बी ० =० = ३, ०76६ = ०१, बी ०85५ = ०, ०0६ = ३०, बी ० ९ ५ = 0.0, B096 = 0.0}

मदद की सराहना!

Comments

हैशमैप लुकअप के लिए है। यह चीजों को राख कर देता है। यह व्यवस्था बनाए नहीं रखता है।

— मुहम्मद हसन खान

@ हसनखान .. किससे भी पूछा?

— eRaisedToX

Answer 1

सॉर्ट किए गए का उपयोग करें TreeMap:

Map<String, Float> map = new TreeMap<>(yourMap);

यह स्वचालित रूप से कुंजियों द्वारा क्रमबद्ध प्रविष्टियों को डाल देगा। मुझे लगता है कि Stringआपके मामले में प्राकृतिक आदेश देना ठीक रहेगा।

ध्यान दें कि HashMapलुकअप ऑप्टिमाइज़ेशन के कारण ऑर्डर संरक्षित नहीं है।

Comments

हाय @Tomasz Nurkiewicz मैं रिवर्स ऑर्डर कैसे प्राप्त कर सकता हूं?

— राघवेंद्र

क्या मैं अपने स्वयं के तुलनित्र को लागू कर सकता हूं

— फखर

महान समाधान! 2 अंक के साथ एक संभावना है, छंटाई 1, 10, 11,12,2,3,4,5 हो जाती है। क्या इसका कोई समाधान है ?

— रचिता नंदा

@RachitaNanda, आप स्ट्रिंग की तुलना में पूर्णांक के साथ अंकों को संग्रहीत करने का प्रयास कर सकते हैं।

— कृष्णा

Answer 2

एक कस्टम तुलनित्र के साथ एक TreeMap का उपयोग करें।

class MyComparator implements Comparator<String>
    {
        public int compare(String o1,String o2)
        {
            // Your logic for comparing the key strings
        }
    }

TreeMap<String, Float> tm = new TreeMap<String , Float>(new MyComparator());

जैसे ही आप नए तत्व जोड़ते हैं, वे स्वचालित रूप से हल हो जाएंगे।

आपके मामले में, एक तुलनित्र को लागू करना भी आवश्यक नहीं हो सकता है क्योंकि स्ट्रिंग ऑर्डर पर्याप्त हो सकता है। लेकिन यदि आप विशेष मामलों को लागू करना चाहते हैं, जैसे कि ऊपरी मामले से पहले निचले मामले अल्फ़ाज़ दिखाई देते हैं, या संख्याओं को एक निश्चित तरीके से मानते हैं, तो तुलनित्र का उपयोग करें।

Answer 3

TreeMapइस तरह की छंटाई (प्राकृतिक) के लिए आपका सबसे अच्छा दांव है। TreeMapकुंजियों के अनुसार स्वाभाविक रूप से।

HashMapप्रविष्टि क्रम को संरक्षित नहीं करता है और न ही यह मानचित्र को क्रमबद्ध करता है। LinkedHashMapप्रविष्टि क्रम रखता है लेकिन मानचित्र को स्वचालित रूप से सॉर्ट नहीं करता है। केवल इंटरफ़ेस TreeMapमें Mapप्राकृतिक क्रम के अनुसार मानचित्र को क्रमबद्ध किया जाता है (अंक पहले, ऊपरी-केस वर्णमाला दूसरा, निचला-केस वर्णमाला अंतिम)।

Answer 4

ट्रीपाइप का उपयोग करें , हालाँकि एक नक्शा "जैसा दिख रहा है" थोड़ा नीरस है - आप बस अपने मानदंड के आधार पर कुंजी को सॉर्ट कर सकते हैं और प्रत्येक ऑब्जेक्ट को पुन: प्राप्त कर सकते हैं।

Answer 5

बस एक का उपयोग करें TreeMap। यह SortedMapइंटरफ़ेस को लागू करता है, और इस प्रकार स्वचालित रूप से इसमें निहित कुंजियों को सॉर्ट करता है। वांछित परिणाम प्राप्त करने के लिए आपकी चाबियाँ बस वर्णानुक्रम में क्रमबद्ध की जा सकती हैं, इसलिए आपको एक तुलनित्र प्रदान करने की आवश्यकता नहीं है।

HashMaps कभी हल नहीं होते हैं। केवल एक चीज जिसे आप हैशपॉप के साथ युग्मित करते हैं, सभी कुंजी प्राप्त होती हैं, और उन्हें एक सॉर्ट किए गए सेट में या एक सूची में संग्रहीत करता है और सूची को सॉर्ट करता है।

Answer 6

ट्रीपैप का उपयोग करके आप मानचित्र को क्रमबद्ध कर सकते हैं।

Map<String, String> map = new HashMap<String, String>();        
Map<String, String> treeMap = new TreeMap<String, String>(map);
//show hashmap after the sort
for (String str : treeMap.keySet()) {
    System.out.println(str);
}

Answer 7

आप उपयोग कर सकते हैं TreeMapजो मूल्यों को क्रमबद्ध रूप में संग्रहीत करेगा।

Map <String, String> map = new TreeMap <String, String>();

Answer 8

ट्रीपॉपर (कंस्ट्रक्टर) का उपयोग करें:

Map<String, Float> sortedMap = new TreeMap<>(yourMap);

TreeMap (पुट विधि) का उपयोग करें:

Map<String, Float> sortedMap = new TreeMap<>();
sortedMap.putAll(yourMap);

मानचित्र इंटरफ़ेस का कार्यान्वयन:

1. ट्रीपैप - सम्मिलित करते समय स्वचालित रूप से आरोही क्रम में कुंजियों को क्रमबद्ध करें।
2. HashMap - सम्मिलन के आदेश को बनाए नहीं रखा जाएगा।
3. LinkedHashMap - प्रविष्टि का क्रम बनाए रखा जाएगा।

Answer 9

ट्रीपैप स्वचालित रूप से आरोही क्रम में क्रमबद्ध हो जाएगा। यदि आप अवरोही क्रम में क्रमबद्ध करना चाहते हैं, तो निम्न कोड का उपयोग करें:

नीचे दिए गए कोड को अपनी कक्षा में और मुख्य निष्पादन विधि के बाहर कॉपी करें:

static class DescOrder implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {      
        return o2.compareTo(o1);
    }
    }

फिर अपने तर्क में:

TreeMap<String, String> map = new TreeMap<String, String>(new DescOrder());
map.put("A", "test1");
map.put("C", "test3");
map.put("E", "test5");
map.put("B", "test2");
map.put("D", "test4");