Самый простой способ перебора через Multiset в порядке частоты элементов?

Рассмотрим этот пример, который выводит статистику некоторых типов устройств. ( "DeviceType" - это перечисление с дюжиными значениями.)

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

Какой самый простой и элегантный способ распечатать отдельные элементы в порядке их частоты (наиболее часто встречающийся тип)?

С быстрым просмотром интерфейса Multiset для этого нет готового метода, и ни один из Guava Multiset реализации (HashMultiset, TreeMultiset и т.д.), как представляется, автоматически сохраняют элементы, упорядоченные по частоте.

Ответ 1

Я просто добавил эту функцию в Guava, см. здесь для Javadoc.

Изменить: пример использования Multisets.copyHighestCountFirst() в соответствии с исходным вопросом:

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

Ответ 2

Здесь метод, который возвращает List записей, отсортированных по частоте (UPDATE): используется флаг для переключения восходящего/нисходящего порядка и использования любимой игрушки Guava: Enum Singleton Pattern, как найдено в Эффективная Java, пункт 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;
}

Тестовый код:

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()));
}

Вывод:

по возрастанию:
Один (1)
Два (2)
Три (3)
Четыре (4)
по убыванию:
Четыре (4)
Три (3)
Два (2)
Один (1)

Ответ 3

Реализация с использованием ForwardingMultiSet:

(EntryComp из seanizer ответ)

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());
    }*/

}

Ответ 4

Поскольку он еще не реализован, я думаю, вы можете создать Map с ключом = тип и value = считать. Затем сортируйте эту карту - см. здесь