Java LinkedHashMap

Mapa de hash vinculado de Java

En este tutorial, aprenderemos sobre la clase Java LinkedHashMap y sus operaciones con la ayuda de ejemplos.

El LinkedHashMap La clase del marco de colecciones de Java proporciona la tabla hash y la implementación de listas enlazadas de la interfaz Map.

El LinkedHashMap La interfaz extiende la clase HashMap para almacenar sus entradas en una tabla hash. Internamente mantiene una lista de enlaces dobles entre todas sus entradas para ordenar sus entradas.

Creación de un LinkedHashMap

Para crear un hashmap vinculado, debemos importar el java.util.LinkedHashMap paquete primero. Una vez que importamos el paquete, así es como podemos crear hashmaps vinculados en Java.

// LinkedHashMap with initial capacity 8 and load factor 0.6
LinkedHashMap<Key, Value> numbers = new LinkedHashMap<>(8, 0.6f);

En el código anterior, hemos creado un hashmap vinculado llamado numbers .

Aquí,

Clave - un identificador único utilizado para asociar cada elemento (valor) en un mapa
Valor - elementos asociados por las claves en un mapa

Observe la parte new LinkedHashMap<>(8, 0.6) . Aquí, el primer parámetro es capacidad y el segundo parámetro es loadFactor .

capacidad - La capacidad de este hashmap vinculado es 8. Es decir, puede almacenar 8 entradas.
factor de carga - El factor de carga de este hashmap vinculado es 0,6. Esto significa que, cada vez que nuestro mapa hash se llena en un 60 %, las entradas se mueven a una nueva tabla hash del doble del tamaño de la tabla hash original.

Capacidad predeterminada y factor de carga

Es posible crear un hashmap vinculado sin definir su capacidad y factor de carga. Por ejemplo,

//LinkedHashMap with default capacity and load factor
LinkedHashMap<Key, Value> numbers1 = new LinkedHashMap<>();

Por defecto,

la capacidad del hashmap vinculado será 16
el factor de carga será 0,75

Nota :El LinkedHashMap class también nos permite definir el orden de sus entradas. Por ejemplo

// LinkedHashMap with specified order
LinkedHashMap<Key, Value> numbers2 = new LinkedHashMap<>(capacity, loadFactor, accessOrder);

Aquí, pedido de acceso es un valor booleano. Su valor por defecto es false . En este caso, las entradas en el hashmap vinculado se ordenan en función de su orden de inserción.

Sin embargo, si true se pasa como accessOrder , las entradas en el hashmap vinculado se ordenarán desde las menos accedidas recientemente hasta las más recientemente accedidas.

Creación de LinkedHashMap a partir de otros mapas

Así es como podemos crear un mapa hash vinculado que contenga todos los elementos de otros mapas.

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        // Creating a LinkedHashMap of even numbers
        LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("LinkedHashMap1: " + evenNumbers);

        // Creating a LinkedHashMap from other LinkedHashMap
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>(evenNumbers);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap2: " + numbers);
    }
}

Salida

LinkedHashMap1: {Two=2, Four=4}
LinkedHashMap2: {Two=2, Four=4, Three=3}

Métodos de LinkedHashMap

Los LinkedHashMap La clase proporciona métodos que nos permiten realizar varias operaciones en el mapa.

Insertar elementos en LinkedHashMap

put() - inserta la asignación clave/valor especificada en el mapa
putAll() - inserta todas las entradas del mapa especificado en este mapa
putIfAbsent() - inserta la asignación clave/valor especificada en el mapa si la clave especificada no está presente en el mapa

Por ejemplo,


import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        // Creating LinkedHashMap of even numbers
        LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();

        // Using put()
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("Original LinkedHashMap: " + evenNumbers);

        // Using putIfAbsent()
        evenNumbers.putIfAbsent("Six", 6);
        System.out.println("Updated LinkedHashMap(): " + evenNumbers);

        //Creating LinkedHashMap of numbers
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("One", 1);

        // Using putAll()
        numbers.putAll(evenNumbers);
        System.out.println("New LinkedHashMap: " + numbers);
    }
}

Salida

Original LinkedHashMap: {Two=2, Four=4}
Updated LinkedHashMap: {Two=2, Four=4, Six=6}
New LinkedHashMap: {One=1, Two=2, Four=4, Six=6}

Acceso a elementos LinkedHashMap

1. Uso de entrySet(), keySet() y valores()

entrySet() - devuelve un conjunto de todas las asignaciones de clave/valor del mapa
keySet() - devuelve un conjunto de todas las claves del mapa
values() - devuelve un conjunto de todos los valores del mapa

Por ejemplo,

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {
        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();

        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap: " + numbers);

        // Using entrySet()
        System.out.println("Key/Value mappings: " + numbers.entrySet());

        // Using keySet()
        System.out.println("Keys: " + numbers.keySet());

        // Using values()
        System.out.println("Values: " + numbers.values());
    }
}

Salida

LinkedHashMap: {One=1, Two=2, Three=3}
Key/Value mappings: [One=1, Two=2, Three=3]
Keys: [One, Two, Three]
Values: [1, 2, 3]

2. Usando get() y getOrDefault()

get() - Devuelve el valor asociado a la clave especificada. Si no se encuentra la clave, devuelve null .
getOrDefault() - Devuelve el valor asociado a la clave especificada. Si no se encuentra la clave, devuelve el valor predeterminado especificado.

Por ejemplo,

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {

        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap: " + numbers);

        // Using get()
        int value1 = numbers.get("Three");
        System.out.println("Returned Number: " + value1);

        // Using getOrDefault()
        int value2 = numbers.getOrDefault("Five", 5);
        System.out.println("Returned Number: " + value2);
    }
}

Salida

LinkedHashMap: {One=1, Two=2, Three=3}
Returned Number: 3
Returned Number: 5

Eliminados elementos LinkedHashMap

remove(key) - devuelve y elimina la entrada asociada con la clave especificada del mapa
remove(key, value) - elimina la entrada del mapa solo si la clave especificada mapeado para ser el valor especificado y devolver un valor booleano

Por ejemplo,

import java.util.LinkedHashMap;

class Main {
    public static void main(String[] args) {

        LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("LinkedHashMap: " + numbers);

        // remove method with single parameter
        int value = numbers.remove("Two");
        System.out.println("Removed value: " + value);

        // remove method with two parameters
        boolean result = numbers.remove("Three", 3);
        System.out.println("Is the entry Three removed? " + result);

        System.out.println("Updated LinkedHashMap: " + numbers);
    }
}

Salida

LinkedHashMap: {One=1, Two=2, Three=3}
Removed value: 2
Is the entry {Three=3} removed? True
Updated LinkedHashMap: {One=1}

Otros métodos de LinkedHashMap

Método	Descripción
`clear()`	elimina todas las entradas del mapa
`containsKey()`	comprueba si el mapa contiene la clave especificada y devuelve un valor booleano
`containsValue()`	comprueba si el mapa contiene el valor especificado y devuelve un valor booleano
`size()`	devuelve el tamaño del mapa
`isEmpty()`	comprueba si el mapa está vacío y devuelve un valor booleano

LinkedHashMap vs. Mapa hash

Tanto el LinkedHashMap y el HashMap implementa el Map interfaz. Sin embargo, existen algunas diferencias entre ellos.

LinkedHashMap mantiene internamente una lista doblemente enlazada. Debido a esto, mantiene el orden de inserción de sus elementos.
El LinkedHashMap la clase requiere más almacenamiento que HashMap . Esto se debe a que LinkedHashMap mantiene listas enlazadas internamente.
El rendimiento de LinkedHashMap es más lento que HashMap .

Mapa hash de Java Java WeakHashMap

Java