मूल्यों की संख्या के आधार पर गुवा मल्टीमैप को क्रमबद्ध करें

Question

यदि मेरे पास गुवा मल्टीमैप है, तो मैं दिए गए कुंजी के मानों की संख्या के आधार पर प्रविष्टियों को कैसे क्रमबद्ध करूं?

उदाहरण के लिए:

Multimap<String, String> multiMap = ArrayListMultimap.create(); 
multiMap.put("foo", "1"); 
multiMap.put("bar", "2"); 
multiMap.put("bar", "3"); 
multiMap.put("bar", "99"); 

को देखते हुए यह, जब मल्टीमैप से अधिक पुनरावृत्ति, मैं कैसे मिलेगा "बार" प्रविष्टियों पहले आने के लिए (के बाद से "बार" 3 मूल्यों बनाम केवल 1 "foo" है)?

Answer 1

एक सूची में प्रविष्टियों निकालें, तो सूची क्रमबद्ध करें:

List<Map.Entry<String, String>> entries = new ArrayList<Map.Entry<String, String>>(map.entries()); 
Collections.sort(entries, new Comparator<Map.Entry<String, String>>() { 
    @Override 
    public int compare(Map.Entry<String, String> e1, Map.Entry<String, String> e2) { 
     return Ints.compare(map.get(e2.getKey()).size(), map.get(e1.getKey()).size()); 
    } 
}); 

तब प्रविष्टियों से अधिक पुनरावृति।

संपादित करें:

List<Map.Entry<String, Collection<String>>> entries = 
    new ArrayList<Map.Entry<String, Collection<String>>>(map.asMap().entrySet()); 
Collections.sort(entries, new Comparator<Map.Entry<String, Collection<String>>>() { 
    @Override 
    public int compare(Map.Entry<String, Collection<String>> e1, 
         Map.Entry<String, Collection<String>> e2) { 
     return Ints.compare(e2.getValue().size(), e1.getValue().size()); 
    } 
}); 

// and now iterate 
for (Map.Entry<String, Collection<String>> entry : entries) { 
    System.out.println("Key = " + entry.getKey()); 
    for (String value : entry.getValue()) { 
     System.out.println(" Value = " + value); 
    } 
} 

Answer 2

मैं मल्टीमैप के keys Multiset प्रविष्टियों का उपयोग करना चाहते हैं,:

यदि आप चाहते हैं आंतरिक नक्शा (Entry<String, Collection<String>>) की प्रविष्टियों से अधिक तथ्य पुनरावृति में है, तो निम्न कार्य करें उन्हें अवरोही आवृत्ति के अनुसार क्रमबद्ध करें (issue 356 में वर्णित कार्यक्षमता को गुवा में जोड़ा जाने वाला कार्यक्षमता आसान हो जाएगा), और क्रमबद्ध कुंजी को पुन: स्थापित करके एक नया मल्टीमैप बनाएं, मूल मल्टीमैप से मूल्य प्राप्त करना:

/** 
* @return a {@link Multimap} whose entries are sorted by descending frequency 
*/ 
public Multimap<String, String> sortedByDescendingFrequency(Multimap<String, String> multimap) { 
    // ImmutableMultimap.Builder preserves key/value order 
    ImmutableMultimap.Builder<String, String> result = ImmutableMultimap.builder(); 
    for (Multiset.Entry<String> entry : DESCENDING_COUNT_ORDERING.sortedCopy(multimap.keys().entrySet())) { 
     result.putAll(entry.getElement(), multimap.get(entry.getElement())); 
    } 
    return result.build(); 
} 

/** 
* An {@link Ordering} that orders {@link Multiset.Entry Multiset entries} by ascending count. 
*/ 
private static final Ordering<Multiset.Entry<?>> ASCENDING_COUNT_ORDERING = new Ordering<Multiset.Entry<?>>() { 
    @Override 
    public int compare(Multiset.Entry<?> left, Multiset.Entry<?> right) { 
     return Ints.compare(left.getCount(), right.getCount()); 
    } 
}; 

/** 
* An {@link Ordering} that orders {@link Multiset.Entry Multiset entries} by descending count. 
*/ 
private static final Ordering<Multiset.Entry<?>> DESCENDING_COUNT_ORDERING = ASCENDING_COUNT_ORDERING.reverse(); 

---

संपादित करें: इस काम नहीं करता है कुछ प्रविष्टियों (मेरी टिप्पणी देखें)

एक और दृष्टिकोण, पर Multimaps 'चाबियाँ मल्टीसेट आधार पर एक आदेश का उपयोग कर, और ImmutableMultimap.Builder.orderKeysBy() एक ही आवृत्ति है:

/** 
* @return a {@link Multimap} whose entries are sorted by descending frequency 
*/ 
public Multimap<String, String> sortedByDescendingFrequency(Multimap<String, String> multimap) { 
    return ImmutableMultimap.<String, String>builder() 
      .orderKeysBy(descendingCountOrdering(multimap.keys())) 
      .putAll(multimap) 
      .build(); 
} 

private static Ordering<String> descendingCountOrdering(final Multiset<String> multiset) { 
    return new Ordering<String>() { 
     @Override 
     public int compare(String left, String right) { 
      return Ints.compare(multiset.count(left), multiset.count(right)); 
     } 
    }; 
} 

दूसरा दृष्टिकोण छोटा है, लेकिन मुझे यह तथ्य पसंद नहीं है कि ऑर्डरिंग में राज्य है (यह चाबियों की तुलना करने के लिए मल्टीमैप की कुंजी मल्टीसेट पर निर्भर करता है)।