Neste tutorial, aprenderemos sobre a classe Java LinkedHashMap e suas operações com a ajuda de exemplos.
A LinkedHashMapclasse da estrutura de coleções Java fornece a tabela hash e a implementação de lista vinculada da interface Map.
A LinkedHashMapinterface estende a classe HashMap para armazenar suas entradas em uma tabela hash. Ele mantém internamente uma lista duplamente vinculada entre todas as suas entradas para ordenar suas entradas.
Criando um LinkedHashMap
Para criar um hashmap vinculado, devemos importar o java.util.LinkedHashMappacote primeiro. Depois de importar o pacote, aqui está como podemos criar hashmaps vinculados em Java.
// LinkedHashMap with initial capacity 8 and load factor 0.6 LinkedHashMap numbers = new LinkedHashMap(8, 0.6f);
No código acima, criamos um hashmap vinculado com o nome de números.
Aqui,
- Chave - um identificador único usado para associar cada elemento (valor) em um mapa
- Valor - elementos associados pelas chaves em um mapa
Observe a peça new LinkedHashMap(8, 0.6). Aqui, o primeiro parâmetro é a capacidade e o segundo parâmetro é loadFactor .
- capacidade - A capacidade deste hashmap vinculado é 8. Ou seja, ele pode armazenar 8 entradas.
- loadFactor - O fator de carga deste hashmap vinculado é de 0,6. Isso significa que, sempre que nosso mapa hash é preenchido em 60%, as entradas são movidas para uma nova tabela hash com o dobro do tamanho da tabela hash original.
Capacidade padrão e fator de carga
É possível criar um hashmap vinculado sem definir sua capacidade e fator de carga. Por exemplo,
//LinkedHashMap with default capacity and load factor LinkedHashMap numbers1 = new LinkedHashMap();
Por padrão,
- a capacidade do hashmap vinculado será de 16
- o fator de carga será 0,75
Nota : A LinkedHashMapclasse também nos permite definir a ordem de suas entradas. Por exemplo
// LinkedHashMap with specified order LinkedHashMap numbers2 = new LinkedHashMap(capacity, loadFactor, accessOrder);
Aqui, accessOrder é um valor booleano. Seu valor padrão é false. Nesse caso, as entradas no hashmap vinculado são ordenadas com base em seu pedido de inserção.
No entanto, se truefor passado como accessOrder, as entradas no hashmap vinculado serão ordenadas do acessado menos recentemente para o acessado mais recentemente.
Criação de LinkedHashMap de outros mapas
Aqui está como podemos criar um hashmap vinculado contendo todos os elementos de outros mapas.
import java.util.LinkedHashMap; class Main ( public static void main(String() args) ( // Creating a LinkedHashMap of even numbers LinkedHashMap evenNumbers = new LinkedHashMap(); evenNumbers.put("Two", 2); evenNumbers.put("Four", 4); System.out.println("LinkedHashMap1: " + evenNumbers); // Creating a LinkedHashMap from other LinkedHashMap LinkedHashMap numbers = new LinkedHashMap(evenNumbers); numbers.put("Three", 3); System.out.println("LinkedHashMap2: " + numbers); ) )
Resultado
LinkedHashMap1: (Dois = 2, Quatro = 4) LinkedHashMap2: (Dois = 2, Quatro = 4, Três = 3)
Métodos de LinkedHashMap
A LinkedHashMapclasse fornece métodos que nos permitem realizar várias operações no mapa.
Inserir elementos em LinkedHashMap
put()- insere o mapeamento de chave / valor especificado no mapaputAll()- insere todas as entradas do mapa especificado para este mapaputIfAbsent()- insere o mapeamento de chave / valor especificado no mapa se a chave especificada não estiver presente no mapa
Por exemplo,
import java.util.LinkedHashMap; class Main ( public static void main(String() args) ( // Creating LinkedHashMap of even numbers LinkedHashMap 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 numbers = new LinkedHashMap(); numbers.put("One", 1); // Using putAll() numbers.putAll(evenNumbers); System.out.println("New LinkedHashMap: " + numbers); ) )
Resultado
LinkedHashMap original: (Two = 2, Four = 4) LinkedHashMap atualizado: (Two = 2, Four = 4, Six = 6) Novo LinkedHashMap: (One = 1, Two = 2, Four = 4, Six = 6)
Acessar elementos LinkedHashMap
1. Usando entrySet (), keySet () e values ()
entrySet()- retorna um conjunto de todos os mapeamentos de chave / valor do mapakeySet()- retorna um conjunto de todas as chaves do mapavalues()- retorna um conjunto de todos os valores do mapa
Por exemplo,
import java.util.LinkedHashMap; class Main ( public static void main(String() args) ( LinkedHashMap 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()); ) )
Resultado
LinkedHashMap: (One = 1, Two = 2, Three = 3) Mapeamentos de chave / valor: (One = 1, Two = 2, Three = 3) Chaves: (One, Two, Three) Valores: (1, 2, 3 )
2. Usando get () e getOrDefault ()
get()- Retorna o valor associado à chave especificada. Se a chave não for encontrada, ele retornanull.getOrDefault()- Retorna o valor associado à chave especificada. Se a chave não for encontrada, ele retorna o valor padrão especificado.
Por exemplo,
import java.util.LinkedHashMap; class Main ( public static void main(String() args) ( LinkedHashMap 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); ) )
Resultado
LinkedHashMap: (One = 1, Two = 2, Three = 3) Número devolvido: 3 Número devolvido: 5
Elementos LinkedHashMap removidos
remove(key)- retorna e remove a entrada associada à chave especificada do maparemove(key, value)- remove a entrada do mapa apenas se a chave especificada mapeada para ser o valor especificado e retornar um valor booleano
Por exemplo,
import java.util.LinkedHashMap; class Main ( public static void main(String() args) ( LinkedHashMap 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); ) )
Resultado
LinkedHashMap: (One = 1, Two = 2, Three = 3) Valor removido: 2 A entrada (Três = 3) foi removida? LinkedHashMap atualizado verdadeiro: (One = 1)
Outros métodos de LinkedHashMap
| Método | Descrição |
|---|---|
clear() | remove todas as entradas do mapa |
containsKey() | verifica se o mapa contém a chave especificada e retorna um valor booleano |
containsValue() | verifica se o mapa contém o valor especificado e retorna um valor booleano |
size() | retorna o tamanho do mapa |
isEmpty() | verifica se o mapa está vazio e retorna um valor booleano |
LinkedHashMap vs. HashMap
Tanto o LinkedHashMapquanto o HashMapimplementam a Mapinterface. No entanto, existem algumas diferenças entre eles.
LinkedHashMapmantém uma lista duplamente vinculada internamente. Por isso, mantém a ordem de inserção de seus elementos.- A
LinkedHashMapclasse requer mais armazenamento do queHashMap. Isso ocorre porqueLinkedHashMapmantém listas vinculadas internamente. - O desempenho de
LinkedHashMapé mais lento do queHashMap.
