क्या HashMap से इसकी स्थिति से तत्व प्राप्त करना संभव है?

Question

अपनी स्थिति के अनुसार हाशप से एक तत्व कैसे प्राप्त करें, क्या यह संभव है?

Comments

"स्थिति" से आपका क्या तात्पर्य है? HashMaps का आदेश नहीं दिया जाता है, इसलिए उनके पास "स्थिति" की सामान्य धारणा नहीं होती है कि आपको वेक्टर जैसी कोई चीज़ मिलेगी।

— Mat

क्या आप इसके सम्मिलन आदेश या कुछ अन्य आदेशों से मतलब रखते हैं?

— मार्क इलियट

Answer 1

HashMaps आदेश को संरक्षित नहीं करते हैं:

यह वर्ग नक्शे के आदेश के अनुसार कोई गारंटी नहीं देता है; विशेष रूप से, यह गारंटी नहीं देता है कि आदेश समय के साथ स्थिर रहेगा।

LinkedHashMap पर एक नज़र डालें , जो एक पूर्वानुमान योग्य पुनरावृत्ति क्रम की गारंटी देता है।

Comments

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

— forresthopkinsa

सम्मान के साथ, यह दस्तावेज का हवाला देता है जो सीधे सवाल का जवाब देता है

— वेन

भले ही आदेश समय के साथ स्थिर न हो, फिर भी किसी दिए गए पद से किसी एक सदस्य को पुनः प्राप्त करना संभव हो सकता है।

— शुरुआत

मैं अनुसरण नहीं करता। के बारे में बताएं?

— वेन

HashMap लिंक टूट गया है / 404।

— रफ

Answer 2

LinkedHashMap का उपयोग करें और जब आपको स्थिति द्वारा पुनर्प्राप्त करने की आवश्यकता होती है, तो मानों को एक ArrayList में परिवर्तित करें।

LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<String,String>();
/* Populate */
linkedHashMap.put("key0","value0");
linkedHashMap.put("key1","value1");
linkedHashMap.put("key2","value2");
/* Get by position */
int pos = 1;
String value = (new ArrayList<String>(linkedHashMap.values())).get(pos);

Comments

हमेशा HashMap से कुंजी की एक प्रति को तुरंत करने की आवश्यकता है ??

— रिचर्ड

यह हर बार जब हम मान प्राप्त करते हैं, तो एक नया ArrayList ऑब्जेक्ट बनाएगा, जिससे मेमोरी लीक होती है

— NullByte08

Answer 3

यदि आप उस आदेश को बनाए रखना चाहते हैं जिसमें आपने तत्वों को मानचित्र में जोड़ा है, तो LinkedHashMapबस विरोध के रूप में उपयोग करें HashMap।

यहाँ एक दृष्टिकोण है जो आपको मानचित्र में इसके सूचकांक द्वारा एक मूल्य प्राप्त करने की अनुमति देगा:

public Object getElementByIndex(LinkedHashMap map,int index){
    return map.get( (map.keySet().toArray())[ index ] );
}

Comments

सरलतम मुझे कहना होगा ... हर चीज़ को परिवर्तित करने के बजाय, आप केवल कीसेट का उपयोग कर रहे हैं। शानदार

— कीर्तनबर्ग

Answer 4

यदि आप किसी कारणवश, हैश-मैप के साथ रहना चाहते हैं, तो आप keySet को एक सरणी में बदल सकते हैं और सरणी में कुंजियों को अनुक्रमणित कर सकते हैं ताकि मानचित्र में मान प्राप्त हो सकें:

Object[] keys = map.keySet().toArray();

तब आप इस तरह के नक्शे का उपयोग कर सकते हैं:

map.get(keys[i]);

Comments

ध्यान दें कि गिरफ्तारी [i] को बदलकर: कुंजियों [i]

— मोहसिन अबसी

ठीक है, मेरे पास नक्शे कुंजी के रूप में स्ट्रिंग्स हैं, उनमें से एक को प्राप्त करने के लिए, दूसरा भाग होगा:String myKey = keys[i].toString();

— ओरिक

Answer 5

उपयोग करें LinkedHashMap:

हैश तालिका और मैप किए गए इंटरफ़ेस की लिंक्ड सूची कार्यान्वयन, पूर्वानुमानित पुनरावृत्ति क्रम के साथ। यह कार्यान्वयन हैशपॉप से ​​इस मायने में भिन्न है कि यह अपनी सभी प्रविष्टियों के माध्यम से चलने वाली दोहरी-लिंक की गई सूची को बनाए रखता है।

Comments

यह आदेश को संरक्षित करेगा, लेकिन आप अभी भी आइटम को उनके सूचकांक तक नहीं पहुंचा सकते हैं। आपको यह

— देखना होगा

यह लिंक API के पुराने संस्करण का है। मैं एक जावा 6 या 7 एपीआई से जोड़ने का सुझाव दूंगा।

— jzd

Answer 6

LinkedHashMap का उपयोग करें और इस फ़ंक्शन का उपयोग करें।

private LinkedHashMap<Integer, String> map = new LinkedHashMap<Integer, String>();

इस तरह परिभाषित करें और

private Entry getEntry(int id){
        Iterator iterator = map.entrySet().iterator();
        int n = 0;
        while(iterator.hasNext()){
            Entry entry = (Entry) iterator.next();
            if(n == id){
                return entry;
            }
            n ++;
        }
        return null;
    }

फ़ंक्शन चयनित प्रविष्टि को वापस कर सकता है।

Answer 7

मैं 'स्थिति' के आधार पर मान रहा हूं कि आप उस क्रम का उल्लेख कर रहे हैं जिसमें आपने तत्वों को हैशमैप में डाला है। उस स्थिति में आप एक LinkedHashMap का उपयोग करना चाहते हैं। LinkedHashMap हालांकि एक सहायक विधि प्रदान नहीं करता है; आपको एक जैसा लिखना होगा

public Object getElementAt(LinkedHashMap map, int index) {
    for (Map.Entry entry : map.entrySet()) {
        if (index-- == 0) {
            return entry.value();
        }
    }
    return null;
}

Answer 8

एक अन्य कार्य दृष्टिकोण मानचित्र मानों को एक सरणी में बदल रहा है और फिर सूचकांक में तत्व को पुनः प्राप्त करता है। निम्नलिखित परिणामों के लिए निम्नलिखित दृष्टिकोणों का उपयोग करके 100 000 ऑब्जेक्ट्स के लिंक्डहाशपैप में सूचकांक खोजों द्वारा 100 000 तत्व का टेस्ट रन:

//My answer:
public Particle getElementByIndex(LinkedHashMap<Point, Particle> map,int index){
    return map.values().toArray(new Particle[map.values().size()])[index];
} //68 965 ms

//Syd Lambert's answer:
public Particle getElementByIndex(LinkedHashMap<Point, Particle> map,int index){
    return map.get( (map.keySet().toArray())[ index ] );
} //80 700 ms

LinkedHashMap से अनुक्रमणिका द्वारा सभी को पुनः प्राप्त करने वाले तत्व में बहुत भारी ऑपरेशन लगता है।

Answer 9

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

Answer 10

HashMap की स्थिति की कोई अवधारणा नहीं है, इसलिए स्थिति से कोई वस्तु प्राप्त करने का कोई तरीका नहीं है। मैप्स में ऑब्जेक्ट्स सेट किए जाते हैं और कुंजियों द्वारा प्राप्त किए जाते हैं।

Answer 11

आप कुंजी प्राप्त करने के लिए नीचे दिए गए कोड का उपयोग कर सकते हैं: String [] keys = (String[]) item.keySet().toArray(new String[0]);

और वस्तु या सूची प्राप्त करें जो इस तरह से इस आइटम की कुंजी के साथ हाशप में डालें: item.get(keys[position]);

Answer 12

डिफ़ॉल्ट रूप से, java LinkedHasMap स्थिति के आधार पर मूल्य प्राप्त करने के लिए समर्थन नहीं करता है। इसलिए मेरा सुझाव है कि अनुकूलित के साथ जाएंIndexedLinkedHashMap

public class IndexedLinkedHashMap<K, V> extends LinkedHashMap<K, V> {

    private ArrayList<K> keysList = new ArrayList<>();

    public void add(K key, V val) {
        super.put(key, val);
        keysList.add(key);
    }

    public void update(K key, V val) {
        super.put(key, val);
    }

    public void removeItemByKey(K key) {
        super.remove(key);
        keysList.remove(key);
    }

    public void removeItemByIndex(int index) {
        super.remove(keysList.get(index));
        keysList.remove(index);
    }

    public V getItemByIndex(int i) {
        return (V) super.get(keysList.get(i));
    }

    public int getIndexByKey(K key) {
        return keysList.indexOf(key);
    }
}

तो आप इस अनुकूलित LinkedHasMap के रूप में उपयोग कर सकते हैं

IndexedLinkedHashMap<String,UserModel> indexedLinkedHashMap=new IndexedLinkedHashMap<>();

मान जोड़ने के लिए

indexedLinkedHashMap.add("key1",UserModel);

सूचकांक द्वारा प्राप्त करने के लिए

indexedLinkedHashMap.getItemByIndex(position);

Answer 13

HashMaps स्थिति तक पहुंच की अनुमति नहीं देता है, यह केवल हैश कोड के बारे में जानता है और यह मान को पुनः प्राप्त कर सकता है यदि यह कुंजी के हैश कोड की गणना कर सकता है। ट्रीमैप में ऑर्डर करने की धारणा है। लिंकेडस नक्शे उस क्रम को संरक्षित करते हैं जिसमें उन्होंने मानचित्र दर्ज किया था।

Answer 14

आप कुछ इस तरह से लागू करने की कोशिश कर सकते हैं:

Map<String, Integer> map = new LinkedHashMap<String, Integer>();
map.put("juan", 2);
map.put("pedro", 3);
map.put("pablo", 5);
map.put("iphoncio",9)

List<String> indexes = new ArrayList<String>(map.keySet()); // <== Parse

System.out.println(indexes.indexOf("juan"));     // ==> 0
System.out.println(indexes.indexOf("iphoncio"));      // ==> 3

मुझे उम्मीद है कि यह आपके लिए काम करेगा।