Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Mezipaměť LRU s LinkedHashMap

Vytvořte v Java SE 21 mezipaměť pro dvě položky a ověřte si, proč načtení klíče změní položku, která se při příštím vložení vyřadí.

Verze: Java SE 21

Syntaxe

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()

V Java SE 21 přijímá LinkedHashMap(int, float, boolean) počáteční kapacitu hašovací tabulky, faktor zaplnění a režim řazení. První dva argumenty neomezují počet položek. Při true probíhá iterace od nejdéle nepoužité položky k naposledy použité: úspěšné get(key) nebo volání put(key, value) přesune příslušnou položku na konec. Při false platí pořadí vložení: načtení existující položky ani nahrazení její hodnoty pomocí put její pozici nezmění.

Chcete-li vyřazovat nejdéle nepoužitou položku (LRU), přepište v podtřídě chráněnou metodu removeEldestEntry(Map.Entry<K,V> eldest). Po přidání nové položky pomocí put nebo putAll umožní návrat hodnoty size() > 2 mapě odstranit první položku, jakmile jsou v ní tři. Nahrazení hodnoty tento mechanismus nespustí. Neměňte mapu uvnitř metody, pokud vracíte true: účinek této kombinace není specifikován.

put(K,V) vloží nebo nahradí hodnotu a remove(Object) odstraní položku podle klíče. Obě metody vracejí předchozí hodnotu nebo null, pokud položka neexistovala nebo měla hodnotu null. Přetížená metoda remove(Object,Object) odstraní položku jen při shodě hodnoty a vrátí boolean. Operace měnící mapu jsou v Map volitelné, ale LinkedHashMap je podporuje. size() počítá dvojice klíč–hodnota.

keySet() vrací množinu klíčů; values() vrací kolekci, která může obsahovat stejné hodnoty vícekrát. Jde o pohledy propojené s mapou, nikoli o kopie: iterace dodržuje pořadí mapy a neoznačuje položky jako právě použité, odstranění přes pohled mění mapu a přidávání není podporováno. Limit se týká počtu položek, nikoli jejich životnosti. Mapa není synchronizovaná; i get může změnit pořadí a zneplatnit aktivní iterátor.

Příklady

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

Výsledek

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

Bez načtení vyřadí vložení `C` položku `A`. Po `get("A")` je pořadí `[B, A]`, takže vložení `C` vyřadí `B`. Závěrečné `remove("A")` vrátí `1` a zůstane jen `C`.

Související lekce

  • Java · Lekce 47 · Pokročilá · Verze: 2

Zdroje