LinkedHashMap de Java

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

La clase LinkedHashMap del Java Collection Framework proporcionaMapa interfazde la implementación de tabla de hash y lista enlazada.

LinkedHashMap heredaHashMapClase, para almacenar sus entradas en una tabla de hash. Mantiene internamente una lista enlazada entre todos los elementos para ordenar las entradas.

Crear un LinkedHashMap

Para crear una lista enlazada, primero debemos importar el paquete java.util.LinkedHashMap. Después de importar el paquete, podemos usar el siguiente método para crear una lista enlazada en Java.

//La capacidad inicial de LinkedHashMap es8La carga factor es 0.6
LinkedHashMap<Key, Value> numbers = new LinkedHashMap<>();8, 0.6f);

En el código anterior, creamos un LinkedHashMap llamado numbers.

Aquí,

• Clave - usado como identificador único para asociar cada elemento (valor) del mapa

• Value - los elementos asociados con las claves del mapa

Nota new LinkedHashMap<>(8,0.6) Esta parte. Aquí, el primer parámetro es capacity, el segundo parámetro es loadFactor.

• capacity -　 La capacidad de esta lista enlazada bidireccional es8. Esto significa que puede almacenar8elementos.

• loadFactor- El factor de carga de esta lista enlazada bidireccional es 0.6. Esto significa que cada vez que el hash map se llena60% se moverán los elementos a una nueva tabla de hash, cuyo tamaño es el doble del de la tabla de hash original.

Capacidad y factor de carga predeterminados

No es necesario definir su capacidad y factor de carga para crear una lista enlazada bidireccional. Por ejemplo,

//LinkedHashMap con capacidad y factor de carga predeterminados
LinkedHashMap<Key, Value> numbers1　= new LinkedHashMap<>();

Por defecto,

• La capacidad de la lista enlazada bidireccional será 16

• El factor de carga será 0.75

NotaNotar que LinkedHashMap permite definir el orden de los elementos. Por ejemplo

//LinkedHashMap con orden especificado
LinkedHashMap<Key, Value> numbers2　= new LinkedHashMap<>(capacity, loadFactor, accessOrder);

Aquí, accessOrder es un valor booleano. El valor predeterminado es false. En este caso, los elementos de la lista enlazada bidireccional se ordenarán según su orden de inserción.

Sin embargo, si el valor de accessOrder es true, los elementos de la lista enlazada bidireccional se ordenarán en el orden de acceso más reciente.

Crear LinkedHashMap a partir de otra lista enlazada bidireccional

A continuación, se muestra cómo crear una lista enlazada bidireccional que contiene todos los elementos de otros mapeos.

import　java.util.LinkedHashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Crear LinkedHashMap de números pares
　　　　　　　　LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();
　　　　　　　　evenNumbers.put("Dos",　2);
　　　　　　　　evenNumbers.put("Cuatro",　4);
　　　　　　　　System.out.println("LinkedHashMap1: "　+　evenNumbers);
　　　　　　　　//Crear LinkedHashMap a partir de otro LinkedHashMap
　　　　　　　　LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>(evenNumbers);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("LinkedHashMap2: "　+　numbers);
　　　　{}
{}

salida de resultados

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

Métodos de LinkedHashMap

Este LinkedHashMap proporciona métodos para realizar varias operaciones en el mapa.

se inserta el elemento en LinkedHashMap

• put() - se inserta la clave especificada/el mapeo de valores se inserta en el mapeo

• putAll() -se insertan todos los elementos del mapeo especificado en este mapa

• putIfAbsent() -si el mapa no contiene la clave especificada, se inserta la clave especificada/el mapeo de valores se inserta en el mapa

por ejemplo，

import　java.util.LinkedHashMap;
class　Main　{
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　Creando LinkedHashMap de números pares
　　　　　　　　LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();
　　　　　　　　//　usando　put()
　　　　　　　　evenNumbers.put("Dos",　2);
　　　　　　　　evenNumbers.put("Cuatro",　4);
　　　　　　　　System.out.println("LinkedHashMap original: "　+　evenNumbers);
　　　　　　　　//　usando　putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Seis",　6);
　　　　　　　　System.out.println("LinkedHashMap actualizado(): "　+　evenNumbers);
　　　　　　　　//Creando LinkedHashMap de numbers
　　　　　　　　LinkedHashMap<String,　Integer>　numbers　=　new　LinkedHashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　//　usando　putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("nuevo LinkedHashMap: "　+　numbers);
　　　　{}
{}

salida de resultados

LinkedHashMap original: {Dos=2, Cuatro=4{}
LinkedHashMap actualizado: {Dos=2, Cuatro=4, Seis=6{}
nuevo LinkedHashMap: {Uno=1,　Two=2, Cuatro=4, Seis=6{}

accediendo a los elementos de LinkedHashMap

1.usando entrySet(), keySet() y values()

• entrySet() -devuelve todas las claves del mapeo/colección de mapeo de valores

• keySet() - devuelve la colección de todas las claves del mapa

• values() - devuelve la colección 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);
　　　　　　　　//　
　　　　　　　　System.out.println("Clave",/Mapeo de Valores: "　+　numbers.entrySet());
　　　　　　　　//　usando　keySet()
　　　　　　　　System.out.println("Claves (Claves): "　+　numbers.keySet());
　　　　　　　　//　usando　values()
　　　　　　　　System.out.println("Valores (Valores): "　+　numbers.values());
　　　　{}
{}

salida de resultados

LinkedHashMap:　{One=1,　Two=2,　Three=3{}
Clave/Mapeo de valor:　[One=1,　Two=2,　Three=3]
Claves（claves）:　[One,　Two,　Three]
Valores（valores）:　[1,　2,　3]

2.usar get() y getOrDefault()

• get() - devuelve el valor asociado con la clave especificada. Si no se encuentra la clave, devuelve null.

• getOrDefault() - devuelve el valor asociado con 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);
　　　　　　　　//　usar get()
　　　　　　　　int　value1　=　numbers.get("Three");
　　　　　　　　System.out.println("devolver números:　"　+　value1);
　　　　　　　　//　usar getOrDefault()
　　　　　　　　int　value2　=　numbers.getOrDefault("Five",　5);
　　　　　　　　System.out.println("devolver números:　"　+　value2);
　　　　{}
{}

salida de resultados

LinkedHashMap:　{One=1,　Two=2,　Three=3{}
devolver números:　3
devolver números:　5

eliminar elementos de LinkedHashMap

• remove(key) - devuelve y elimina el elemento asociado con la clave especificada.

• remove(key, value) - se elimina la entrada del mapeo solo cuando se mapea la clave key a su valor value y se devuelve 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);
　　　　　　　　//método de eliminación con un solo parámetro
　　　　　　　　int　value　=　numbers.remove("Two");
　　　　　　　　System.out.println("valor eliminado:　"　+　value);
　　　　　　　　//método de eliminación con dos parámetros
　　　　　　　　boolean　result　=　numbers.remove("Three",　3);
　　　　　　　　System.out.println("entrada3¿fue eliminado?　"　+　result);
　　　　　　　　System.out.println("LinkedHashMap actualizado:　"　+　numbers);
　　　　{}
{}

salida de resultados

LinkedHashMap:　{One=1,　Two=2,　Three=3{}
删除值:　2
条目3被删除了吗？　True
更新后的LinkedHashMap:　{One=1{}

LinkedHashMap的其他方法

LinkedHashMap 与 HashMap 的区别

LinkedHashMap和HashMap都实现Map接口。但是，它们之间存在一些差异。

• LinkedHashMap在内部维护一个双向链表。因此，它保持其元素的插入顺序。

• LinkedHashMap类需要比HashMap更多的存储空间。这是因为LinkedHashMap在内部维护链表。

• LinkedHashMap的性能比HashMap慢。