Question

I am looking at a redundant list of Strings, e.g.

{ "One", "One", "One", "Two", "Three", "Three" }

What is the best way to count the occurrences, then create a non-redundant list of the strings, sorted by the number of occurrences?

The result I want is a List like this:

{ "One", "Three", "Two" }

Answer 1

You can use the trick in the most voted answer of this question about how to sort the map by its values.

Here is an example implementation (I have added generics to the comparator):

• you add the strings / occurences to a hashmap
• put everything in a TreeMap with a custom comparator that sorts on the values
• put the keys back in a list

public static void main(String[] args) {
    String[] strings = {"One", "One", "One", "Two", "Three", "Three"};

    //Count occurences
    Map<String, Integer> map = new HashMap<String, Integer>();

    for (String s : strings) {
        if (map.containsKey(s)) {
            map.put(s, map.get(s) + 1);
        } else {
            map.put(s, 1);
        }
    }

    ValueComparator<String, Integer> comparator = new ValueComparator<String, Integer> (map);
    Map<String, Integer> sortedMap = new TreeMap<String, Integer> (comparator);
    sortedMap.putAll(map);

    List<String> sortedList = new ArrayList<String> (sortedMap.keySet());

    System.out.println(sortedMap);
    System.out.println(sortedList);

}

static class ValueComparator<K, V extends Comparable<V>> implements Comparator<K> {

    Map<K, V> map;

    public ValueComparator(Map<K, V> base) {
        this.map = base;
    }

    @Override
    public int compare(K o1, K o2) {
         return map.get(o2).compareTo(map.get(o1));
    }
}