Question

I have a large map of String->Integer and I want to find the highest 5 values in the map. My current approach involves translating the map into an array list of pair(key, value) object and then sorting using Collections.sort() before taking the first 5. It is possible for a key to have its value updated during the course of operation.

I think this approach is acceptable single threaded, but if I had multiple threads all triggering the transpose and sort frequently it doesn’t seem very efficient. The alternative seems to be to maintain a separate list of the highest 5 entries and keep it updated when relevant operations on the map take place.

Could I have some suggestions/alternatives on optimizing this please? Am happy to consider different data structures if there is benefit.

Thanks!

Answer 1

I think this approach is acceptable single threaded, but if I had multiple threads all triggering the transpose and sort frequently it doesn’t seem very efficient. The alternative seems to be to maintain a separate list of the highest 5 entries and keep it updated when relevant operations on the map take place.

There is an approach in between that you can take as well. When a thread requests a “sorted view” of the map, create a copy of the map and then handle the sorting on that.

public List<Integer> getMaxFive() {
    Map<String, Integer> copy = null;
    synchronized(lockObject) {
        copy = new HashMap<String, Integer>(originalMap);
    }

    //sort the copy as usual
    return list;
}

Ideally if you have some state (such as this map) accessed by multiple threads, you are encapsulating the state behind some other class so that each thread is not updating the map directly.