Java LinkedHashMap

Neste tutorial, aprenderemos sobre a classe Java LinkedHashMap e suas operações com a ajuda de exemplos.

O LinkedHashMap A classe da estrutura de coleções Java fornece a tabela de hash e a implementação de lista vinculada da interface Map.

O LinkedHashMap A interface estende a classe HashMap para armazenar suas entradas em uma tabela de 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.LinkedHashMap pacote primeiro. Depois de importar o pacote, veja como podemos criar hashmaps vinculados em Java.

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

No código acima, criamos um hashmap vinculado chamado numbers .

Aqui,

Chave - um identificador único usado para associar cada elemento (valor) em um mapa
Valor - elementos associados pelas chaves em um mapa

Observe a parte new LinkedHashMap<>(8, 0.6) . Aqui, o primeiro parâmetro é 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 é 0,6. Isso significa que, sempre que nosso mapa de hash for preenchido em 60%, as entradas serão movidas para uma nova tabela de hash com o dobro do tamanho da tabela de hash original.

Capacidade e fator de carga padrão

É possível criar um hashmap vinculado sem definir sua capacidade e fator de carga. Por exemplo,

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

Por padrão,

a capacidade do hashmap vinculado será de 16
o fator de carga será de 0,75

Observação :O LinkedHashMap class também nos permite definir a ordem de suas entradas. Por exemplo

// LinkedHashMap with specified order
LinkedHashMap<Key, Value> 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 sua ordem de inserção.

No entanto, se true é passado como accessOrder , as entradas no hashmap vinculado serão ordenadas do acesso menos recente ao acesso mais recente.

Criando 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<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);
    }
}

Saída

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

Métodos de LinkedHashMap

O LinkedHashMap classe fornece métodos que nos permitem realizar várias operações no mapa.

Inserir elementos no LinkedHashMap

put() - insere o mapeamento de chave/valor especificado no mapa
putAll() - insere todas as entradas do mapa especificado para este mapa
putIfAbsent() - 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<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);
    }
}

Saída

Original LinkedHashMap: {Two=2, Four=4}
Updated LinkedHashMap: {Two=2, Four=4, Six=6}
New 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 mapa
keySet() - retorna um conjunto de todas as chaves do mapa
values() - retorna um conjunto de todos os valores do mapa

Por exemplo,

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());
    }
}

Saída

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() e getOrDefault()

get() - Retorna o valor associado à chave especificada. Se a chave não for encontrada, ela retornará null .
getOrDefault() - Retorna o valor associado à chave especificada. Se a chave não for encontrada, ela retornará o valor padrão especificado.

Por exemplo,

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);
    }
}

Saída

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

Elementos LinkedHashMap removidos

remove(key) - retorna e remove a entrada associada à chave especificada do mapa
remove(key, value) - remove a entrada do mapa somente se a chave especificada mapeado para ser o valor especificado e retorne um valor booleano

Por exemplo,

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);
    }
}

Saída

LinkedHashMap: {One=1, Two=2, Three=3}
Removed value: 2
Is the entry {Three=3} removed? True
Updated LinkedHashMap: {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. Mapa de hash

Tanto o LinkedHashMap e o HashMap implementa o Map interface. No entanto, existem algumas diferenças entre eles.

LinkedHashMap mantém uma lista duplamente ligada internamente. Por isso, mantém a ordem de inserção de seus elementos.
Os LinkedHashMap classe requer mais armazenamento do que HashMap . Isso ocorre porque LinkedHashMap mantém listas vinculadas internamente.
O desempenho de LinkedHashMap é mais lento que HashMap .

Java HashMap Java WeakHashMap

Java