जावा में हैश मैप को कैसे क्रमबद्ध करें

Question

हम HashMap<key, ArrayList> को सॉर्ट करने में सक्षम कैसे हैं?

मैं ArrayList में किसी मान के आधार पर सॉर्ट करना चाहता हूं।

Answer 1

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

Answer 2

क्या आपको हैश मैप का उपयोग करना है? आप केवल मानचित्र इंटरफ़ेस का उपयोग एक TreeMap

---

ठीक है मैं अब लगता है कि मैं अपने प्रश्न समझ में आ जरूरत है, तो आप HashMap के मानों की तुलना के आधार पर सॉर्ट करना चाहते हैं। तो आप में अपने तत्वों डालूँ

Map<String, Person> people = new HashMap<String, Person>(); 

    Person jim = new Person("Jim", 25); 
    Person scott = new Person("Scott", 28); 
    Person anna = new Person("Anna", 23); 

    people.put(jim.getName(), jim); 
    people.put(scott.getName(), scott); 
    people.put(anna.getName(), anna); 

    // not yet sorted 
    List<Person> peopleByAge = new ArrayList<Person>(people.values()); 

    Collections.sort(peopleByAge, new Comparator<Person>() { 

     public int compare(Person o1, Person o2) { 
      return o1.getAge() - o2.getAge(); 
     } 
    }); 

    for (Person p : peopleByAge) { 
     System.out.println(p.getName() + "\t" + p.getAge()); 
    } 

आप अक्सर इस क्रमबद्ध सूची तक पहुँच चाहते हैं,: आप अगर तुम यह करने के लिए एक बार आप अपने HashMap के मूल्यों सॉर्ट कर सकते हैं चाहते हैं, यह करने के लिए कोड लिखने के लिए है हैश मैप और एक क्रमबद्ध सेट (उदाहरण के लिए ट्रीसेट) में ...

Answer 3

ऐसा लगता है कि आप एक ट्रेमैप चाहते हैं।

http://docs.oracle.com/javase/7/docs/api/java/util/TreeMap.html

आप इसे करने के लिए एक कस्टम तुलनित्र में पारित कर सकते हैं कि अगर लागू होता है।

Answer 4

यदि आप सॉर्ट किए गए मैप के साथ कुशल पुनर्प्राप्ति के लिए मानचित्र को जोड़ना चाहते हैं, तो आप ConcurrentSkipListMap का उपयोग कर सकते हैं।

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

Answer 5

http://snipplr.com/view/2789/sorting-map-keys-by-comparing-its-values/

कुंजी

List keys = new ArrayList(yourMap.keySet()); 

मिल उन्हें क्रमबद्ध

Collections.sort(keys) 

उन्हें मुद्रित।

किसी भी मामले में, आप एपीआई This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time] के अनुसार HashMap (में मानों हल कर सकते हैं नहीं किया है।

हालांकि आप, LinkedHashMap करने के लिए इन सभी मूल्यों को धक्का कर सकते हैं बाद में उपयोग करने के लिए।

Answer 6

This हो सकता है आप के लिए क्या देख रहे हो यह दिखाता है कि उपयोग करने के लिए कैसे ट्री-मैप और एक कस्टम तुलनाकारी काम किया जाना

Answer 7

सॉर्ट की गई सूची hasmap कुंजी द्वारा:।।

SortedSet<String> keys = new TreeSet<String>(myHashMap.keySet()); 

सॉर्ट की गई सूची hashmap मूल्यों से:

SortedSet<String> values = new TreeSet<String>(myHashMap.values()); 

गुड लक!

Answer 8

जावा 8 में:

Comparator<Entry<String, Item>> valueComparator = 
    (e1, e2) -> e1.getValue().getField().compareTo(e2.getValue().getField()); 

Map<String, Item> sortedMap = 
    unsortedMap.entrySet().stream(). 
    sorted(valueComparator). 
    collect(Collectors.toMap(Entry::getKey, Entry::getValue, 
          (e1, e2) -> e1, LinkedHashMap::new)); 

Guava का उपयोग करना:

Map<String, Item> map = ...; 
Function<Item, Integer> getField = new Function<Item, Integer>() { 
    public Integer apply(Item item) { 
     return item.getField(); // the field to sort on 
    } 
}; 
comparatorFunction = Functions.compose(getField, Functions.forMap(map)); 
comparator = Ordering.natural().onResultOf(comparatorFunction); 
Map<String, Item> sortedMap = ImmutableSortedMap.copyOf(map, comparator); 

Answer 9

कस्टम तुलना समारोह जो तुर्की वर्णमाला या अंग्रेज़ी के अलावा अन्य अलग-अलग भाषाओं के लिए कार्यक्षमता भी शामिल है।

public <K extends Comparable,V extends Comparable> LinkedHashMap<K,V> sortByKeys(LinkedHashMap<K,V> map){ 
    List<K> keys = new LinkedList<K>(map.keySet()); 
    Collections.sort(keys, (Comparator<? super K>) new Comparator<String>() { 
     @Override 
     public int compare(String first, String second) { 
      Collator collator = Collator.getInstance(Locale.getDefault()); 
      //Collator collator = Collator.getInstance(new Locale("tr", "TR")); 
      return collator.compare(first, second); 
     } 
    }); 

    LinkedHashMap<K,V> sortedMap = new LinkedHashMap<K,V>(); 
    for(K key: keys){ 
     sortedMap.put(key, map.get(key)); 
    } 

    return sortedMap; 
} 

यहाँ

का उपयोग कर उदाहरण निम्नलिखित

LinkedHashMap<String, Boolean> ligList = new LinkedHashMap<String, Boolean>(); 
ligList = sortByKeys(ligList); 

Answer 10

आप एक LinkedHashMap < का उपयोग कर विचार किया है के रूप में है>() ..?

public static void main(String[] args) { 
    Map<Object, Object> handler = new LinkedHashMap<Object, Object>(); 
    handler.put("item", "Value"); 
    handler.put(2, "Movies"); 
    handler.put("isAlive", true); 

    for (Map.Entry<Object, Object> entrY : handler.entrySet()) 
     System.out.println(entrY.getKey() + ">>" + entrY.getValue()); 

    List<Map.Entry<String, Integer>> entries = new ArrayList<Map.Entry<String, Integer>>(); 
    Collections.sort(entries, new Comparator<Map.Entry<String, Integer>>() { 
     public int compare(Map.Entry<String, Integer> a, 
       Map.Entry<String, Integer> b) { 
      return a.getValue().compareTo(b.getValue()); 
     } 
    }); 
} 

परिणामस्वरूप एक संगठित लिंक में परिणाम।

item>>Value 
2>>Movies 
isAlive>>true 

जांच .. छँटाई हिस्सा here से उठाया

Answer 11

मैं एक पूरी तरह से परीक्षण काम कर समाधान का विकास किया। आशा है कि यह मदद करता है के द्वारा मूल्य

import java.io.BufferedReader; 
import java.io.IOException; 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.HashMap; 
import java.util.List; 
import java.util.StringTokenizer; 


public class Main { 
    public static void main(String[] args) { 
    try { 
     BufferedReader in = new BufferedReader(new java.io.InputStreamReader   (System.in)); 
      String str; 

     HashMap<Integer, Business> hm = new HashMap<Integer, Business>(); 
     Main m = new Main(); 


     while ((str = in.readLine()) != null) { 


      StringTokenizer st = new StringTokenizer(str); 
      int id = Integer.parseInt(st.nextToken()); // first integer 
      int rating = Integer.parseInt(st.nextToken()); // second 

      Business a = m.new Business(id, rating); 


      hm.put(id, a); 


      List<Business> ranking = new ArrayList<Business>(hm.values()); 

      Collections.sort(ranking, new Comparator<Business>() { 

       public int compare(Business i1, Business i2) { 
        return i2.getRating() - i1.getRating(); 
       } 
      }); 

      for (int k=0;k<ranking.size();k++) { 
       System.out.println((ranking.get(k).getId() + " " + (ranking.get(k)).getRating())); 
      } 


     } 
     in.close(); 

    } catch (IOException e) { 
     e.printStackTrace(); 
    } 


} 
public class Business{ 

    Integer id; 
    Integer rating; 

    public Business(int id2, int rating2) 
    { 
     id=id2; 
     rating=rating2; 

    } 

    public Integer getId() 
    { 
     return id; 
    } 
    public Integer getRating() 
    { 
     return rating; 
    } 


} 
} 

Answer 12

छंटाई HashMap:

के रूप में अन्य लोगों ने बताया है। हैश मैप्स आसान लुकअप के लिए हैं यदि आप इसे बदलते हैं या मानचित्र के अंदर क्रमबद्ध करने का प्रयास करते हैं तो आपके पास अब ओ (1) लुकअप नहीं होगा।

class Obj implements Comparable<Obj>{ 
    String key; 
    ArrayList<Integer> val; 
    Obj(String key, ArrayList<Integer> val) 
    { 
    this.key=key; 
    this.val=val; 
    } 
    public int compareTo(Obj o) 
    { 
    /* Write your sorting logic here. 
    this.val compared to o.val*/ 
    return 0; 
    } 
} 

public void sortByValue(Map<String, ArrayList<>> mp){ 

    ArrayList<Obj> arr=new ArrayList<Obj>(); 
    for(String z:mp.keySet())//Make an object and store your map into the arrayList 
    { 

     Obj o=new Obj(z,mp.get(z)); 
     arr.add(o); 
    } 
    System.out.println(arr);//Unsorted 
    Collections.sort(arr);// This sorts based on the conditions you coded in the compareTo function. 
    System.out.println(arr);//Sorted 
} 

Answer 13

मैं एक वर्ग है जो कुंजी और मूल्यों के आधार पर एक नक्शा सॉर्ट करने के लिए इस्तेमाल किया जा सकता का विकास किया है:

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

public static void main(String[] args) { 
    Map<String, Integer> unSortedMap = new LinkedHashMap<String, Integer>(); 
    unSortedMap.put("A", 2); 
    unSortedMap.put("V", 1); 
    unSortedMap.put("G", 5); 
    System.out.println("Unsorted Map :\n"); 
    for (Map.Entry<String, Integer> entry : unSortedMap.entrySet()) { 
     System.out.println(entry.getKey() + " " + entry.getValue()); 
    } 
    System.out.println("\n"); 
    System.out.println("Sorting Map Based on Keys :\n"); 
    Map<String, Integer> keySortedMap = new TreeMap<String, Integer>(unSortedMap); 
    for (Map.Entry<String, Integer> entry : keySortedMap.entrySet()) { 
     System.out.println(entry.getKey() + " " + entry.getValue()); 
    } 
    System.out.println("\n"); 
    System.out.println("Sorting Map Based on Values :\n"); 
    List<Entry<String, Integer>> entryList = new ArrayList<Entry<String, Integer>>(unSortedMap.entrySet()); 
    Collections.sort(entryList, new Comparator<Entry<String, Integer>>() { 

     @Override 
     public int compare(Entry<String, Integer> obj1, Entry<String, Integer> obj2) { 
      return obj1.getValue().compareTo(obj2.getValue()); 
     } 
    }); 
    unSortedMap.clear(); 
    for (Entry<String, Integer> entry : entryList) { 
     unSortedMap.put(entry.getKey(), entry.getValue()); 
     System.out.println(entry.getKey() + " " + entry.getValue()); 
    } 
} 

कोड ठीक से परीक्षण किया जाता है:

यहाँ पूर्ण समाधान है डी

Answer 14

HashMap does not किसी भी व्यवस्था बनाए रखने, तो आप आदेश देने के किसी भी प्रकार चाहते हैं, तो आप स्टोर करने के लिए है कि में की जरूरत है कुछ और, जो एक नक्शा है और इसमें कुछ प्रकार का ऑर्डरिंग हो सकता है, जैसे LinkedHashMap

नीचे एक साधारण प्रोग्राम है, जिसके द्वारा आप कुंजी, मूल्य, आरोही, अवरोही द्वारा क्रमबद्ध कर सकते हैं ..(यदि आप कॉम्पैक्टर संशोधित करने, आप, आदेश के किसी भी प्रकार का उपयोग कर सकते कुंजी और मूल्यों पर)

package com.edge.collection.map; 

import java.util.Collections; 
import java.util.Comparator; 
import java.util.HashMap; 
import java.util.LinkedHashMap; 
import java.util.LinkedList; 
import java.util.List; 
import java.util.Map; 
import java.util.Map.Entry; 

public class SortMapByKeyValue { 
Map<String, Integer> map = new HashMap<String, Integer>(); 

public static void main(String[] args) { 

    SortMapByKeyValue smkv = new SortMapByKeyValue(); 
    smkv.createMap(); 

    System.out.println("After sorting by key ascending order......"); 
    smkv.sortByKey(true); 

    System.out.println("After sorting by key descindeng order......"); 
    smkv.sortByKey(false); 

    System.out.println("After sorting by value ascending order......"); 
    smkv.sortByValue(true); 

    System.out.println("After sorting by value descindeng order......"); 
    smkv.sortByValue(false); 

} 

void createMap() { 
    map.put("B", 55); 
    map.put("A", 80); 
    map.put("D", 20); 
    map.put("C", 70); 
    map.put("AC", 70); 
    map.put("BC", 70); 
    System.out.println("Before sorting......"); 
    printMap(map); 
} 

void sortByValue(boolean order) { 

    List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(map.entrySet()); 
    Collections.sort(list, new Comparator<Entry<String, Integer>>() { 
     public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) { 
      if (order) { 
       return o1.getValue().compareTo(o2.getValue()); 
      } else { 
       return o2.getValue().compareTo(o1.getValue()); 

      } 
     } 
    }); 
    Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>(); 
    for (Entry<String, Integer> entry : list) { 
     sortedMap.put(entry.getKey(), entry.getValue()); 
    } 
    printMap(sortedMap); 

} 

void sortByKey(boolean order) { 

    List<Entry<String, Integer>> list = new LinkedList<Entry<String, Integer>>(map.entrySet()); 
    Collections.sort(list, new Comparator<Entry<String, Integer>>() { 
     public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) { 
      if (order) { 
       return o1.getKey().compareTo(o2.getKey()); 
      } else { 
       return o2.getKey().compareTo(o1.getKey()); 

      } 
     } 
    }); 
    Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>(); 
    for (Entry<String, Integer> entry : list) { 
     sortedMap.put(entry.getKey(), entry.getValue()); 
    } 
    printMap(sortedMap); 
} 

public void printMap(Map<String, Integer> map) { 
    // System.out.println(map); 
    for (Entry<String, Integer> entry : map.entrySet()) { 
     System.out.println(entry.getKey() + " : " + entry.getValue()); 
    } 
} 
} 

यहाँ Git link