Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Una caché LRU con LinkedHashMap

Crea una caché de dos entradas en Java SE 21 y comprueba por qué leer una clave cambia qué entrada se expulsa en la siguiente inserción.

Versión: Java SE 21

Sintaxis

LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
@Override protected boolean removeEldestEntry(Map.Entry<K, V> eldest)
V put(K key, V value)
V get(Object key)
V remove(Object key)
boolean remove(Object key, Object value)
Collection<V> values()
int size()
Set<K> keySet()

En Java SE 21, LinkedHashMap(int, float, boolean) recibe la capacidad inicial de la tabla hash, el factor de carga y el modo de ordenación. Los dos primeros argumentos no limitan el número de entradas. Con true, se recorre desde la entrada usada hace más tiempo hasta la más reciente: un get(key) que encuentra la clave o un put(key, value) mueve la entrada correspondiente al final. Con false, se sigue el orden de inserción: ni leer una entrada existente ni reemplazar su valor con put cambia su posición.

Para expulsar la entrada usada hace más tiempo (LRU), sobrescribe el método protegido removeEldestEntry(Map.Entry<K,V> eldest) en una subclase. Tras añadir una entrada nueva mediante put o putAll, devolver size() > 2 permite al mapa eliminar su primera entrada cuando llega a tres. Reemplazar un valor no activa este mecanismo. No modifiques el mapa dentro del método si devuelves true: el efecto de combinar ambas acciones no está especificado.

put(K,V) inserta o reemplaza un valor y remove(Object) elimina por clave. Ambos devuelven el valor anterior, o null si no había asociación o si su valor era null. La sobrecarga remove(Object,Object) solo elimina la asociación si coincide el valor y devuelve un boolean. Las modificaciones son opcionales en Map, pero LinkedHashMap las admite. size() cuenta las asociaciones clave-valor.

keySet() devuelve un conjunto de claves; values() devuelve una colección que puede contener valores repetidos. Son vistas vinculadas al mapa, no copias: se recorren en el orden del mapa sin actualizar el orden de uso, eliminar desde una vista cambia el mapa y no se permite añadir elementos. El límite afecta al número de entradas, no a su tiempo de permanencia. El mapa no está sincronizado; incluso get puede cambiar el orden e invalidar un iterador activo.

Ejemplos

import java.util.LinkedHashMap;
import java.util.Map;

public class Main {
    private static final class LruCache<K, V> extends LinkedHashMap<K, V> {
        private static final int MAX_ENTRIES = 2;

        LruCache() {
            super(4, 0.75f, true);
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
            return size() > MAX_ENTRIES;
        }
    }

    private static void show(String label, Map<String, Integer> cache) {
        System.out.println(label + ": keys=" + cache.keySet()
                + ", values=" + cache.values() + ", size=" + cache.size());
    }

    public static void main(String[] args) {
        Map<String, Integer> noRead = new LruCache<>();
        noRead.put("A", 1);
        noRead.put("B", 2);
        noRead.put("C", 3);
        show("No read, after put(C)", noRead);

        Map<String, Integer> withRead = new LruCache<>();
        withRead.put("A", 1);
        withRead.put("B", 2);
        System.out.println("get(A) = " + withRead.get("A"));
        show("With read, before put(C)", withRead);
        withRead.put("C", 3);
        show("With read, after put(C)", withRead);
        System.out.println("remove(A) = " + withRead.remove("A"));
        show("After remove(A)", withRead);
    }
}

Resultado

No read, after put(C): keys=[B, C], values=[2, 3], size=2
get(A) = 1
With read, before put(C): keys=[B, A], values=[2, 1], size=2
With read, after put(C): keys=[A, C], values=[1, 3], size=2
remove(A) = 1
After remove(A): keys=[C], values=[3], size=1

Sin lectura, insertar `C` expulsa `A`. Después de `get("A")`, el orden es `[B, A]`, así que insertar `C` expulsa `B`. El último `remove("A")` devuelve `1` y solo queda `C`.

Lecciones relacionadas

  • Java · Lección 47 · Avanzado · Versión: 2

Fuentes