LinkedHashMap en Java

La clase LinkedHashMap es como HashMap con una característica adicional de mantener un orden de elementos insertados en ella. HashMap proporcionó la ventaja de una inserción, búsqueda y eliminación rápidas, pero nunca mantuvo el seguimiento y el orden de inserción, que proporciona LinkedHashMap donde se puede acceder a los elementos en su orden de inserción. 

Las características importantes de un LinkedHashMap se enumeran a continuación:

• Un LinkedHashMap contiene valores basados ​​en la clave. Implementa la interfaz Map y amplía la clase HashMap.
• Contiene sólo elementos únicos.
• Puede tener una clave nula y múltiples valores nulos.
• No está sincronizado.
• Es lo mismo que HashMap con la característica adicional de que mantiene el orden de inserción. Por ejemplo, cuando ejecutamos el código con un HashMap, obtenemos un orden diferente de elementos.

Declaración:

public class LinkedHashMap<K,​V> extends HashMap<K,​V> implements Map<K,​V>

Aquí, K es el tipo de objeto clave y V es el tipo de objeto de valor

• K – El tipo de claves en el mapa.
• V – El tipo de valores mapeados en el mapa.

Implementa la interfaz Map<K, V> y amplía la clase HashMap<K, V> . Aunque la Jerarquía de LinkedHashMap es como se muestra en los siguientes medios de la siguiente manera :

¿Cómo funciona LinkedHashMap internamente?

Un LinkedHashMap es una extensión de la clase HashMap e implementa la interfaz Map . Por lo tanto, la clase se declara como:

public class LinkedHashMap 
extends HashMap 
implements Map 

En esta clase, los datos se almacenan en forma de Nodes. La implementación de LinkedHashMap es muy similar a una lista doblemente enlazada . Por lo tanto, cada Node del LinkedHashMap se representa como:

• Hash: todas las claves de entrada se convierten en un hash, que es una forma más corta de la clave para que la búsqueda y la inserción sean más rápidas.
• Clave: dado que esta clase extiende HashMap, los datos se almacenan en forma de un par clave-valor. Por lo tanto, este parámetro es la clave de los datos.
• Valor: para cada clave, hay un valor asociado a ella. Este parámetro almacena el valor de las claves. Debido a los genéricos, este valor puede ser de cualquier forma.
• Siguiente: dado que LinkedHashMap almacena la orden de inserción, esta contiene la dirección del siguiente Node de LinkedHashMap.
• Anterior: este parámetro contiene la dirección del Node anterior de LinkedHashMap.

LinkedHashMap sincronizado

La implementación de LinkedHashMap no está sincronizada. Si varios subprocesos acceden a un mapa hash vinculado al mismo tiempo y al menos uno de los subprocesos modifica el mapa estructuralmente, debe sincronizarse externamente. Esto generalmente se logra mediante la sincronización en algún objeto que encapsula naturalmente el mapa. Si no existe tal objeto, el mapa debe «envolverse» utilizando el método Collections.synchronizedMap . Es mejor hacerlo en el momento de la creación, para evitar el acceso no sincronizado accidental al mapa:

Map m = Collections.synchronizedMap(new LinkedHashMap(...));

Constructores de la clase LinkedHashMap

Para crear un LinkedHashMap , necesitamos crear un objeto de la clase LinkedHashMap. La clase LinkedHashMap consta de varios constructores que permiten la posible creación de ArrayList. Los siguientes son los constructores disponibles en esta clase:

1. LinkedHashMap(): se utiliza para construir un constructor LinkedHashMap predeterminado.

LinkedHashMap<K, V> lhm = new LinkedHashMap<K, V>();

2. LinkedHashMap (capacidad int): se utiliza para inicializar un LinkedHashMap particular con una capacidad específica.

LinkedHashMap<K, V> lhm = new LinkedHashMap<K, V>(int capacity);

3. LinkedHashMap(Map <? extends K ,​? extends V > map ): Se utiliza para inicializar un LinkedHashMap particular con los elementos del mapa especificado.

LinkedHashMap<K, V> lhm = new LinkedHashMap<K, V>(Map<? extends K,​? extends V> map);

4. LinkedHashMap(int capacity, float fillRatio): se utiliza para inicializar tanto la capacidad como la tasa de llenado de un LinkedHashMap. Un fillRatio también llamado loadFactor es una métrica que determina cuándo aumentar el tamaño del LinkedHashMap automáticamente. De forma predeterminada, este valor es 0,75, lo que significa que el tamaño del mapa aumenta cuando el mapa está lleno en un 75 %.

LinkedHashMap<K, V> lhm = new LinkedHashMap<K, V>(int capacity, float fillRatio);

5. LinkedHashMap(int capacity, float fillRatio, boolean Order): este constructor también se utiliza para inicializar tanto la capacidad como la tasa de llenado de un LinkedHashMap junto con si se debe seguir el orden de inserción o no.

LinkedHashMap<K, V> lhm = new LinkedHashMap<K, V>(int capacity, float fillRatio, boolean Order);

Aquí, para el atributo Pedido , se pasa verdadero para el último pedido de acceso y falso para el pedido de inserción.

 Métodos de LinkedHashMap 

Aplicación: dado que LinkedHashMap utiliza Doubly LinkedList para mantener el orden de inserción, podemos implementar la funcionalidad LRU Cache anulando el método removeEldestEntry() para imponer una política para eliminar automáticamente obsoletos cuando se agregan nuevas asignaciones al mapa. Esto le permite caducar los datos utilizando algunos criterios que defina.

Ejemplo:

// Java Program to Demonstrate Working of LinkedHashMap
 
// Importing required classes
import java.util.*;
 
// LinkedHashMapExample
public class GFG {
 
    // Main driver method
    public static void main(String a[])
    {
 
        // Creating an empty LinkedHashMap
        LinkedHashMap<String, String> lhm
            = new LinkedHashMap<String, String>();
 
        // Adding entries in Map
        // using put() method
        lhm.put("one", "practice.geeksforgeeks.org");
        lhm.put("two", "code.geeksforgeeks.org");
        lhm.put("four", "quiz.geeksforgeeks.org");
 
        // Printing all entries inside Map
        System.out.println(lhm);
 
        // Note: It prints the elements in same order
        // as they were inserted
 
        // Getting and printing value for a specific key
        System.out.println("Getting value for key 'one': "
                           + lhm.get("one"));
 
        // Getting size of Map using size() method
        System.out.println("Size of the map: "
                           + lhm.size());
 
        // Checking whether Map is empty or not
        System.out.println("Is map empty? "
                           + lhm.isEmpty());
 
        // Using containsKey() method to check for a key
        System.out.println("Contains key 'two'? "
                           + lhm.containsKey("two"));
 
        // Using containsKey() method to check for a value
        System.out.println(
            "Contains value 'practice.geeks"
            + "forgeeks.org'? "
            + lhm.containsValue("practice"
                                + ".geeksforgeeks.org"));
 
        // Removing entry using remove() method
        System.out.println("delete element 'one': "
                           + lhm.remove("one"));
 
        // Printing mappings to the console
        System.out.println("Mappings of LinkedHashMap : "
                           + lhm);
    }
}

{one=practice.geeksforgeeks.org, two=code.geeksforgeeks.org, four=quiz.geeksforgeeks.org}
Getting value for key 'one': practice.geeksforgeeks.org
Size of the map: 3
Is map empty? false
Contains key 'two'? true
Contains value 'practice.geeksforgeeks.org'? true
delete element 'one': practice.geeksforgeeks.org
Mappings of LinkedHashMap : {two=code.geeksforgeeks.org, four=quiz.geeksforgeeks.org}

 Varias operaciones en la clase LinkedHashMap

Veamos cómo realizar algunas operaciones de uso frecuente en la instancia de la clase LinkedHashMap.

Operación 1: Adición de elementos

Para agregar un elemento a LinkedHashMap, podemos usar el método put(). Esto es diferente de HashMap porque en HashMap , el orden de inserción no se conserva, pero se conserva en LinkedHashMap. 

Ejemplo

// Java Program to Demonstrate Adding
// Elements to a LinkedHashMap
 
// Importing required classes
import java.util.*;
 
// Main class
// AddElementsToLinkedHashMap
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Initialization of a LinkedHashMap
        // using Generics
        LinkedHashMap<Integer, String> hm1
            = new LinkedHashMap<Integer, String>();
 
        // Add mappings to Map
        // using put() method
        hm1.put(3, "Geeks");
        hm1.put(2, "For");
        hm1.put(1, "Geeks");
 
        // Printing mappings to the console
        System.out.println("Mappings of LinkedHashMap : "
                           + hm1);
    }
}

Mappings of LinkedHashMap : {3=Geeks, 2=For, 1=Geeks}

Operación 2: Cambiar/Actualizar Elementos

Después de agregar elementos, si deseamos cambiar el elemento, se puede hacer agregando nuevamente el elemento usando el método put(). Dado que los elementos en LinkedHashMap se indexan usando las claves, el valor de la clave se puede cambiar simplemente reinsertando el valor actualizado para la clave que deseamos cambiar.

Ejemplo

// Java Program to Demonstrate Updation of Elements
// of LinkedHashMap
 
import java.util.*;
 
// Main class
// UpdatingLinkedHashMap
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Initialization of a LinkedHashMap
        // using Generics
        LinkedHashMap<Integer, String> hm
            = new LinkedHashMap<Integer, String>();
 
        // Inserting mappings into Map
        // using put() method
        hm.put(3, "Geeks");
        hm.put(2, "Geeks");
        hm.put(1, "Geeks");
 
        // Printing mappings to the console
        System.out.println("Initial map : " + hm);
 
        // Updating the value with key 2
        hm.put(2, "For");
 
        // Printing the updated Map
        System.out.println("Updated Map : " + hm);
    }
}

Initial map : {3=Geeks, 2=Geeks, 1=Geeks}
Updated Map : {3=Geeks, 2=For, 1=Geeks}

Operación 3: Quitar elemento

Para eliminar un elemento de LinkedHashMap, podemos usar el método remove(). Este método toma el valor de la clave como entrada, busca la existencia de dicha clave y luego elimina la asignación de la clave de este LinkedHashMap si está presente en el mapa. Aparte de eso, también podemos eliminar el primer elemento ingresado del mapa si se define el tamaño máximo.

Ejemplo

// Java program to Demonstrate Removal of Elements
// from LinkedHashMap
 
// Importing utility classes
import java.util.*;
 
// Main class
// RemovingMappingsFromLinkedHashMap
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Initialization of a LinkedHashMap
        // using Generics
        LinkedHashMap<Integer, String> hm
            = new LinkedHashMap<Integer, String>();
 
        // Inserting the Elements
        // using put() method
        hm.put(3, "Geeks");
        hm.put(2, "Geeks");
        hm.put(1, "Geeks");
        hm.put(4, "For");
 
        // Printing the mappings to the console
        System.out.println("Initial Map : " + hm);
 
        // Removing the mapping with Key 4
        hm.remove(4);
 
        // Printing the updated map
        System.out.println("Updated Map : " + hm);
    }
}

Initial Map : {3=Geeks, 2=Geeks, 1=Geeks, 4=For}
Updated Map : {3=Geeks, 2=Geeks, 1=Geeks}

 Operación 4: Iterando a través de LinkedHashMap

Hay varias formas de iterar a través de LinkedHashMap. La forma más famosa es usar un bucle for-each sobre la vista establecida del mapa (obtenido usando el método de instancia map.entrySet()). Luego, para cada entrada (elemento de conjunto), los valores de clave y valor se pueden obtener utilizando el método getKey() y getValue() .

Ejemplo

// Java program to demonstrate
// Iterating over LinkedHashMap
 
// Importing required classes
import java.util.*;
 
// Main class
// IteratingOverLinkedHashMap
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Initialization of a LinkedHashMap
        // using Generics
        LinkedHashMap<Integer, String> hm
            = new LinkedHashMap<Integer, String>();
 
        // Inserting elements into Map
        // using put() method
        hm.put(3, "Geeks");
        hm.put(2, "For");
        hm.put(1, "Geeks");
 
        // For-each loop for traversal over Map
        for (Map.Entry<Integer, String> mapElement :
             hm.entrySet()) {
 
            Integer key = mapElement.getKey();
 
            // Finding the value
            // using getValue() method
            String value = mapElement.getValue();
 
            // Printing the key-value pairs
            System.out.println(key + " : " + value);
        }
    }
}

3 : Geeks
2 : For
1 : Geeks

Artículos relacionados: 

• Implementación de caché LRU
• Diferencias entre TreeMap, HashMap y LinkedHashMap en Java