Comment limiter la taille maximale d’une carte en supprimant les entrées les plus anciennes lorsque la limite est atteinte

Vous pouvez utiliser LinkedHashMap comme ceci

Vous pouvez supprimer par LRU ou FIFO.

public static  Map createLRUMap(final int maxEnsortinges) { return new LinkedHashMap(maxEnsortinges*10/7, 0.7f, true) { @Override protected boolean removeEldestEntry(Map.Entry eldest) { return size() > maxEnsortinges; } }; } 

J’utilise un cours personnel qui fait ce dont vous avez besoin. Une fois la carte pleine, les objects les plus anciens utilisés sont supprimés lors de l’insertion. Il utilise un hashmap et une liste liée.

Vous avez deux méthodes à lire:

• peek (qui ne marque pas l’object comme récemment accédé)
• get (qui marque l’object comme récemment accédé et empêche ainsi son retrait pendant un certain temps)

Voici la classe (commentaires supprimés car ils étaient en français):

 import java.util.HashMap; import java.util.Map; public final class HashCache { public interface Disposer { void dispose(T t); } class Maillon { public K cle; public Maillon precedent; public Maillon suivant; public T contenu; } private Map barrette = new HashMap(); private Maillon sumt; private Maillon fond; private int tailleCache = 100; private Disposer disposer; @SuppressWarnings("unchecked") public HashCache(int tailleCache) { if (tailleCache>2) this.tailleCache = tailleCache; Maillon[] maillons = new HashCache.Maillon[tailleCache]; sumt = maillons[0] = new Maillon(); for (int i=1; i(); Maillon[] t = new HashCache.Maillon[tailleCache]; sumt = t[0] = new Maillon(); for (int i=1; i getDisposer() { return disposer; } public void setDisposer(Disposer disposer) { this.disposer = disposer; } } 

Voici une implémentation qui encapsule un HashMap normal et délègue les appels de méthode. La seule différence est que la carte ne peut pas dépasser la capacité maximale.

 import java.util.Collection; import java.util.HashMap; import java.util.LinkedList; import java.util.Map; import java.util.Queue; import java.util.Set; public class CacheMap implements Map { private final Map delegate = new HashMap(); private Queue keyInsertionOrder = new LinkedList(); private final int maxCapacity; public CacheMap(int maxCapacity) { if (maxCapacity < 1) { throw new IllegalArgumentException( "Capacity must be greater than 0"); } this.maxCapacity = maxCapacity; } @Override public void clear() { delegate.clear(); } @Override public boolean containsKey(Object key) { return delegate.containsKey(key); } @Override public boolean containsValue(Object value) { return delegate.containsValue(value); } @Override public Set> entrySet() { return delegate.entrySet(); } @Override public boolean equals(Object o) { return delegate.equals(o); } @Override public V get(Object key) { return delegate.get(key); } @Override public int hashCode() { return delegate.hashCode(); } @Override public boolean isEmpty() { return delegate.isEmpty(); } @Override public Set keySet() { return delegate.keySet(); } @Override public V put(K key, V value) { V previous = delegate.put(key, value); keyInsertionOrder.remove(key); keyInsertionOrder.add(key); if (delegate.size() > maxCapacity) { K oldest = keyInsertionOrder.poll(); delegate.remove(oldest); } return previous; } @Override public void putAll(Map m) { for (K key : m.keySet()) { put(key, m.get(key)); } } @Override public V remove(Object key) { keyInsertionOrder.remove(key); return delegate.remove(key); } @Override public int size() { return delegate.size(); } @Override public Collection values() { return delegate.values(); } } 

S’il ne s’agit pas d’un devoir, je vous recommande vivement d’utiliser une bibliothèque tierce pour éviter d’avoir à concevoir, tester et entretenir votre propre solution.

Voir par exemple le mécanisme Guava MapMaker .