Question

I am looking for a data structure that operates similar to a hash table, but where the table has a size limit. When the number of items in the hash reaches the size limit, a culling function should be called to get rid of the least-retrieved key/value pairs in the table.

Here’s some pseudocode of what I’m working on:

class MyClass {   private Map<Integer, Integer> cache = new HashMap<Integer, Integer>();   public int myFunc(int n) {     if(cache.containsKey(n))       return cache.get(n);     int next = . . . ; //some complicated math.  guaranteed next != n.     int ret = 1 + myFunc(next);     cache.put(n, ret);     return ret;   } } 

What happens is that there are some values of n for which myFunc() will be called lots of times, but many other values of n which will only be computed once. So the cache could fill up with millions of values that are never needed again. I’d like to have a way for the cache to automatically remove elements that are not frequently retrieved.

This feels like a problem that must be solved already, but I’m not sure what the data structure is that I would use to do it efficiently. Can anyone point me in the right direction?

---

Update I knew this had to be an already-solved problem. It’s called an LRU Cache and is easy to make by extending the LinkedHashMap class. Here is the code that incorporates the solution:

class MyClass {   private final static int SIZE_LIMIT = 1000;   private Map<Integer, Integer> cache =     new LinkedHashMap<Integer, Integer>(16, 0.75f, true) {       protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest)       {         return size() > SIZE_LIMIT;       }   };   public int myFunc(int n) {     if(cache.containsKey(n))       return cache.get(n);     int next = . . . ; //some complicated math.  guaranteed next != n.     int ret = 1 + myFunc(next);     cache.put(n, ret);     return ret;   } } 

Answer 1

You are looking for an LRUList/Map. Check out LinkedHashMap:

The removeEldestEntry(Map.Entry) method may be overridden to impose a policy for removing stale mappings automatically when new mappings are added to the map.