Einfachste Möglichkeit, ein Multiset in der Reihenfolge der Elementhäufigkeit zu durchlaufen?

Question

Betrachten Sie dieses Beispiel, das einige Gerätetyp-Statistiken ausgibt. („Device“ ist eine Enumeration mit dozenish Werten.)

Multiset<DeviceType> histogram = getDeviceStats(); 
for (DeviceType type : histogram.elementSet()) { 
    System.out.println(type + ": " + histogram.count(type)); 
} 

Was ist die einfachste, elegante Weise, die verschiedene Elemente in der Reihenfolge ihrer Häufigkeit (häufigste Art zuerst) zu drucken?

Mit einem kurzen Blick auf die Multiset Schnittstelle, gibt es keine fertige Methode hierfür, und keiner von Multiset Implementierungen des Guava (HashMultiset, TreeMultiset usw.) scheinen automatisch Elemente zu halten frequenz bestellt entweder.

Answer 1

ich gerade um diese Funktion zu Guava hinzugefügt, siehe here für die Javadoc.

bearbeiten: Verwendungsbeispiel von Multisets.copyHighestCountFirst() gemäß der ursprünglichen Frage:

Multiset<DeviceType> histogram = getDeviceStats(); 
for (DeviceType type : Multisets.copyHighestCountFirst(histogram).elementSet()) { 
    System.out.println(type + ": " + histogram.count(type)); 
} 

Answer 2

Seit it is not yet implemented, ich denke, Sie können eine Map mit key = type und value = count erstellen. sortieren dann die Karte - siehe here

Answer 3

Hier ist eine Methode, die eine List von Einträgen zurückgibt, sortiert nach Häufigkeit (UPDATE: verwendet, um eine Fahne auf-/absteigend zu wechseln und verwendet Guava Lieblingsspielzeug: die Enum Singleton Pattern, wie gefunden in Effective Java Punkt 3):

private enum EntryComp implements Comparator<Multiset.Entry<?>>{ 
    DESCENDING{ 
     @Override 
     public int compare(final Entry<?> a, final Entry<?> b){ 
      return Ints.compare(b.getCount(), a.getCount()); 
     } 
    }, 
    ASCENDING{ 
     @Override 
     public int compare(final Entry<?> a, final Entry<?> b){ 
      return Ints.compare(a.getCount(), b.getCount()); 
     } 
    }, 
} 

public static <E> List<Entry<E>> getEntriesSortedByFrequency(
    final Multiset<E> ms, final boolean ascending){ 
    final List<Entry<E>> entryList = Lists.newArrayList(ms.entrySet()); 
    Collections.sort(entryList, ascending 
     ? EntryComp.ASCENDING 
     : EntryComp.DESCENDING); 
    return entryList; 
} 

Code Test:

final Multiset<String> ms = 
    HashMultiset.create(Arrays.asList(
     "One", 
     "Two", "Two", 
     "Three", "Three", "Three", 
     "Four", "Four", "Four", "Four" 
    )); 

System.out.println("ascending:"); 
for(final Entry<String> entry : getEntriesSortedByFrequency(ms, true)){ 
    System.out.println(MessageFormat.format("{0} ({1})", 
     entry.getElement(), entry.getCount())); 
} 

System.out.println("descending:"); 
for(final Entry<String> entry : getEntriesSortedByFrequency(ms, false)){ 
    System.out.println(MessageFormat.format("{0} ({1})", 
     entry.getElement(), entry.getCount())); 
} 

Ausgang:

aufsteigend:
Ein (1)
Zwei (2)
Drei (3)
Vier (4)
absteigend:
Vier (4)
Drei (3)
Zwei (2)
Ein (1)

Answer 4

An Implementation ForwardingMultiSet mit:

(EntryComp von seanizer'sanswer)

enum EntryComp implements Comparator<Multiset.Entry<?>> { 
    DESCENDING { 
     @Override 
     public int compare(final Entry<?> a, final Entry<?> b) { 
      return Ints.compare(b.getCount(), a.getCount()); 
     } 
    }, 
    ASCENDING { 
     @Override 
     public int compare(final Entry<?> a, final Entry<?> b) { 
      return Ints.compare(a.getCount(), b.getCount()); 
     } 
    }, 
} 

public class FreqSortMultiSet<E> extends ForwardingMultiset<E> { 
    Multiset<E> delegate; 
    EntryComp comp; 

    public FreqSortMultiSet(Multiset<E> delegate, boolean ascending) { 
     this.delegate = delegate; 
     if (ascending) 
      this.comp = EntryComp.ASCENDING; 
     else 
      this.comp = EntryComp.DESCENDING; 
    } 

    @Override 
    protected Multiset<E> delegate() { 
     return delegate; 
    } 

    @Override 
    public Set<Entry<E>> entrySet() { 
     TreeSet<Entry<E>> sortedEntrySet = new TreeSet<Entry<E>>(comp); 
     sortedEntrySet.addAll(delegate.entrySet()); 
     return sortedEntrySet; 
    } 

    @Override 
    public Set<E> elementSet() { 
     Set<E> sortedEntrySet = new LinkedHashSet<E>(); 
     for (Entry<E> en : entrySet()) 
      sortedEntrySet.add(en.getElement()); 
     return sortedEntrySet; 
    } 

    public static <E> FreqSortMultiSet<E> create(boolean ascending) { 
     return new FreqSortMultiSet<E>(HashMultiset.<E> create(), ascending); 
    } 

    /* 
    * For Testing 
    * public static void main(String[] args) { 
     Multiset<String> s = FreqSortMultiSet.create(false); 
     s.add("Hello"); 
     s.add("Hello"); 
     s.setCount("World", 3); 
     s.setCount("Bye", 5); 
     System.out.println(s.entrySet()); 
    }*/ 

}