Java LinkedHashMap

Carte de hachage liée Java

Dans ce didacticiel, nous allons découvrir la classe Java LinkedHashMap et ses opérations à l'aide d'exemples.

Le LinkedHashMap La classe du framework de collections Java fournit la table de hachage et l'implémentation de la liste chaînée de l'interface Map.

Le LinkedHashMap L'interface étend la classe HashMap pour stocker ses entrées dans une table de hachage. Il maintient en interne une liste à double lien entre toutes ses entrées pour ordonner ses entrées.

Création d'un LinkedHashMap

Afin de créer un hashmap lié, nous devons importer le java.util.LinkedHashMap paquet d'abord. Une fois que nous avons importé le package, voici comment nous pouvons créer des hashmaps liés en Java.

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

Dans le code ci-dessus, nous avons créé un hashmap lié nommé numbers .

Ici,

Clé - un identifiant unique utilisé pour associer chaque élément (valeur) dans une carte
Valeur - éléments associés par les clés dans une carte

Remarquez la partie new LinkedHashMap<>(8, 0.6) . Ici, le premier paramètre est la capacité et le deuxième paramètre est loadFactor .

capacité - La capacité de ce hashmap lié est de 8. Cela signifie qu'il peut stocker 8 entrées.
facteur de charge - Le facteur de charge de ce hashmap lié est de 0,6. Cela signifie que chaque fois que notre carte de hachage est remplie à 60 %, les entrées sont déplacées vers une nouvelle table de hachage de la taille du double de la table de hachage d'origine.

Capacité et facteur de charge par défaut

Il est possible de créer un hashmap lié sans définir sa capacité et son facteur de charge. Par exemple,

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

Par défaut,

la capacité du hashmap lié sera de 16
le facteur de charge sera de 0,75

Remarque :Le LinkedHashMap class nous permet également de définir l'ordre de ses entrées. Par exemple

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

Ici, accessOrder est une valeur booléenne. Sa valeur par défaut est false . Dans ce cas, les entrées du hashmap lié sont classées en fonction de leur ordre d'insertion.

Cependant, si true est passé en tant que accessOrder , les entrées du hashmap lié seront classées du moins récemment consulté au plus récemment consulté.

Créer LinkedHashMap à partir d'autres cartes

Voici comment nous pouvons créer un hashmap lié contenant tous les éléments d'autres cartes.

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

Sortie

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

Méthodes de LinkedHashMap

Le LinkedHashMap fournit des méthodes qui nous permettent d'effectuer diverses opérations sur la carte.

Insérer des éléments dans LinkedHashMap

put() - insère le mappage clé/valeur spécifié dans la carte
putAll() - insère toutes les entrées de la carte spécifiée dans cette carte
putIfAbsent() - insère le mappage clé/valeur spécifié dans la carte si la clé spécifiée n'est pas présente dans la carte

Par exemple,


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

Sortie

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

Accéder aux éléments LinkedHashMap

1. Utilisation de entrySet(), keySet() et values()

entrySet() - renvoie un ensemble de tous les mappages clé/valeur de la carte
keySet() - renvoie un ensemble de toutes les clés de la carte
values() - renvoie un ensemble de toutes les valeurs de la carte

Par exemple,

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

Sortie

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. Utiliser get() et getOrDefault()

get() - Renvoie la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, elle renvoie null .
getOrDefault() - Renvoie la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, elle renvoie la valeur par défaut spécifiée.

Par exemple,

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

Sortie

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

Éléments LinkedHashMap supprimés

remove(key) - renvoie et supprime l'entrée associée à la clé spécifiée de la carte
remove(key, value) - supprime l'entrée de la carte uniquement si la clé spécifiée mappé pour être la valeur spécifiée et renvoie une valeur booléenne

Par exemple,

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

Sortie

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

Autres méthodes de LinkedHashMap

Méthode	Description
`clear()`	supprime toutes les entrées de la carte
`containsKey()`	vérifie si la carte contient la clé spécifiée et renvoie une valeur booléenne
`containsValue()`	vérifie si la carte contient la valeur spécifiée et renvoie une valeur booléenne
`size()`	renvoie la taille de la carte
`isEmpty()`	vérifie si la carte est vide et renvoie une valeur booléenne

LinkedHashMap contre. Carte de hachage

Le LinkedHashMap et le HashMap implémente le Map interface. Cependant, il existe quelques différences entre eux.

LinkedHashMap maintient une liste doublement liée en interne. De ce fait, il conserve l'ordre d'insertion de ses éléments.
Le LinkedHashMap la classe nécessite plus de stockage que HashMap . C'est parce que LinkedHashMap maintient des listes liées en interne.
Les performances de LinkedHashMap est plus lent que HashMap .

Java HashMap Java WeakHashMap

Java