हैश मैप में पहले कैसे पुनरावृत्ति?

Question

मैं HashMap

items = new HashMap<String, String>(); 
     items.put("A", "1"); 
     items.put("B", "2"); 
     items.put("C", "3"); 

मैं प्रत्येक पहले करने के लिए पिछले के लिए की जरूरत है।

"C", "3" 
"B", "2" 
"A", "1" 

Answer 1

संपादित करें: मेरे और मैथ्यू के स्पष्ट रूप से आपके प्रश्न का क्या अर्थ है इसकी अलग-अलग व्याख्याएं हैं। क्या आपका मतलब है कि आपके द्वारा डाला गया रिवर्स ऑर्डर, या चाबियों के रिवर्स ऑर्डर?

तुम्हारा मतलब तो चाबियों का क्रम को उल्टा, यहाँ इसे कैसे करना है:

एक आदेश दिया मानचित्र का उपयोग करें और ट्री-मैप की तरह है, तो items.keySet से अधिक पुनरावृति()। अपनी चाबी का एक SortedSet बना सकते हैं -

Map<String, String> items = new TreeMap<String, String>(new Comparator<String>() { 
    public int compare(String a, String b) { 
    return b.compareTo(a); 
    } 
}); 

items.put("A", "1"); 
items.put("B", "2"); 
items.put("C", "3"); 

for (String s: items.keySet()) { 
    System.out.println(s + " " + items.get(s)); 
} 

Answer 2

HashMap किसी भी आदेश गारंटी नहीं है। यदि आप LinkedHashMap का उपयोग करते हैं, तो इसे सम्मिलन द्वारा आदेश दिया जाएगा, लेकिन अभी भी पीछे जाने का कोई सुविधाजनक तरीका नहीं है।

एक तरीका items.entrySet() पर कॉल करना होगा। यह Set<Map.Entry> देता है। फिर आप सेट का आकार प्राप्त कर सकते हैं, toArray() पर कॉल करें, फिर लूप के लिए अवरोही करें।

Answer 3

एक अन्य विधि: अपने प्रमुख मूल्यों की प्राकृतिक व्यवस्था से

ट्री-मैप प्रकार है, तो आप उलटे क्रम में चाबियाँ सॉर्ट करने के लिए निर्माता के लिए एक तुलनित्र में पारित करने के लिए की आवश्यकता होगी :

import java.util.*; 

class MyComparator implements Comparator<String> { 
    public int compare(String a, String b) { 
     return -a.compareTo(b); 
    } 

    public boolean equals(String a, String b) { 
     return a.equals(b); 
    } 
} 

public class test { 
    public static void main(String[] args) { 
     HashMap<String, String> items = new HashMap<String, String>(); 
     items.put("A", "1"); 
     items.put("B", "2"); 
     items.put("C", "3"); 

     TreeSet<String> ts = new TreeSet<String>(new MyComparator()); 
     ts.addAll(items.keySet()); 
     for(Iterator<String> i = ts.iterator(); i.hasNext();) { 
      String key = i.next(); 
      System.out.println("key: " + key + ", value: " + items.get(key)); 
     } 
    } 
} 

उत्पादन:

 
key: C, value: 3 
key: B, value: 2 
key: A, value: 1 

Answer 4

आप NavigableMap (TreeMapNavigableMap) का उपयोग कर सकते हैं, जो नेविगेशन क्षमताओं के साथ SortedMap है।

NavigableMap#descendingMap() इस मानचित्र में निहित मैपिंग के एक रिवर्स ऑर्डर व्यू (प्रतिलिपि नहीं) देता है।

उदाहरण:

NavigableMap<String, String> items = new TreeMap<String, String>(); 
items.put("B", "2"); 
items.put("A", "1"); 
items.put("C", "3"); 

for (Map.Entry<String, String> e : items.entrySet()) { 
    System.out.println(e); 
} 
// gives 
// A=1 
// B=2 
// C=3 

for (Map.Entry<String, String> e : items.descendingMap().entrySet()) { 
    System.out.println(e); 
} 

// gives 
// C=3 
// B=2 
// A=1 

नोट: यह जवाब मान्य है अगर आप अपने Map में चाबियों का प्राकृतिक आदेश के बारे में परवाह। यदि आप सम्मिलन आदेश या एक्सेस ऑर्डरिंग की परवाह करते हैं, तो LinkedHashMap पर एक नज़र डालें।

नोट 2: आपके प्रश्न में, आपने HashMap का उपयोग किया था। कृपया ध्यान दें कि HashMap अपने तत्वों के लिए किसी भी आदेश की गारंटी नहीं देता है। असल में, यह गारंटी भी नहीं देता कि आदेश समय के साथ स्थिर रहेगा। आगे संदर्भों के लिए HashMap के javadoc का पहला पैराग्राफ देखें।