What is a data structure kind of like a hash table, but infrequently-used keys are deleted?

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; } } ```