¿Alguna vez has trabajado con LinkedHashMap?

Sí, he tenido experiencia. LinkedHashMap en Java y Kotlin es una implementación de la interfaz Map. Combina las propiedades de HashMap (acceso rápido por clave O(1) en promedio) y LinkedList (mantiene el orden de inserción de los elementos).

Características principales:

• Mantenimiento del orden: La iteración sobre los elementos se realiza en el orden en que fueron añadidos.
• Rendimiento: La adición, eliminación y búsqueda de elementos se realiza con una complejidad amortizada constante (O(1)), como en HashMap.
• Memoria: En comparación con HashMap, LinkedHashMap utiliza un poco más de memoria para almacenar las conexiones entre los elementos.
• Modo de acceso: Puede configurarse para mantener el orden de acceso (los elementos utilizados por última vez se mueven al final de la lista), lo cual es útil para implementar cachés con política de reemplazo de menos utilizados (LRU - Least Recently Used).

Ejemplo de uso para una caché LRU:

// Crear una caché con tamaño máximo de 5
// true en el constructor activa el modo de acceso
LinkedHashMap<String, String> lruCache = new LinkedHashMap<>(5, 0.75f, true) {
    @Override
    protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
        // Elimina el elemento más antiguo si el tamaño supera 5
        return size() > 5;
    }
};

lruCache.put("key1", "value1");
lruCache.put("key2", "value2");
lruCache.put("key3", "value3");
System.out.println(lruCache.get("key1")); // Accede a key1, se mueve al final
lruCache.put("key4", "value4");
lruCache.put("key5", "value5");
lruCache.put("key6", "value6"); // La caché supera el tamaño, se elimina el más antiguo (key2, si sin acceso; key3, si con acceso a key1)

System.out.println(lruCache);

// Crear una caché con modo de acceso (true)
val lruCache = object : LinkedHashMap<String, String>(5, 0.75f, true) {
    override fun removeEldestEntry(eldest: Map.Entry<String, String>?): Boolean {
        // Elimina el elemento más antiguo si el tamaño supera 5
        return size > 5
    }
}

lruCache["key1"] = "value1"
lruCache["key2"] = "value2"
lruCache["key3"] = "value3"
println(lruCache["key1"]) // Accede a key1, se mueve al final
lruCache["key4"] = "value4"
lruCache["key5"] = "value5"
lruCache["key6"] = "value6" // La caché supera el tamaño, se elimina el más antiguo

println(lruCache)

LinkedHashMap es útil cuando el orden de iteración sobre los elementos es importante, así como para implementar cachés LRU simples.