Hai mai lavorato con LinkedHashMap?

Sì, ho esperienza. LinkedHashMap in Java e Kotlin è un'implementazione dell'interfaccia Map. Combina le proprietà di HashMap (accesso rapido tramite chiave O(1) in media) e LinkedList (mantiene l'ordine di inserimento degli elementi).

Caratteristiche principali:

• Mantenimento dell'ordine: L'iterazione sugli elementi avviene nell'ordine in cui sono stati aggiunti.
• Prestazioni: L'aggiunta, la rimozione e la ricerca di elementi avvengono con una complessità amortizzata costante (O(1)), come in HashMap.
• Memoria: Rispetto a HashMap, LinkedHashMap utilizza un po' più di memoria per memorizzare i collegamenti tra gli elementi.
• Modalità di accesso: Può essere configurata per mantenere l'ordine di accesso (gli elementi più recentemente usati vengono spostati alla fine della lista), utile per implementare cache con politica di sostituzione dei meno usati (LRU - Least Recently Used).

Esempio di utilizzo per una cache LRU:

// Creiamo una cache con dimensione massima di 5
// true nel costruttore attiva la modalità di accesso
LinkedHashMap<String, String> lruCache = new LinkedHashMap<>(5, 0.75f, true) {
    @Override
    protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
        // Rimuove l'elemento più vecchio se la dimensione supera 5
        return size() > 5;
    }
};

lruCache.put("key1", "value1");
lruCache.put("key2", "value2");
lruCache.put("key3", "value3");
System.out.println(lruCache.get("key1")); // Accesso a key1, si sposta alla fine
lruCache.put("key4", "value4");
lruCache.put("key5", "value5");
lruCache.put("key6", "value6"); // La cache supera la dimensione, viene rimosso il più vecchio (key2, se senza accesso; key3, se con accesso a key1)

System.out.println(lruCache);

// Creiamo una cache con modalità di accesso (true)
val lruCache = object : LinkedHashMap<String, String>(5, 0.75f, true) {
    override fun removeEldestEntry(eldest: Map.Entry<String, String>?): Boolean {
        // Rimuove l'elemento più vecchio se la dimensione supera 5
        return size > 5
    }
}

lruCache["key1"] = "value1"
lruCache["key2"] = "value2"
lruCache["key3"] = "value3"
println(lruCache["key1"]) // Accesso a key1, si sposta alla fine
lruCache["key4"] = "value4"
lruCache["key5"] = "value5"
lruCache["key6"] = "value6" // La cache supera la dimensione, viene rimosso il più vecchio

println(lruCache)

LinkedHashMap è utile quando l'ordine di iterazione sugli elementi è importante, così come per implementare cache LRU semplici.