Java LinkedHashMap

在本教程中，我们将借助示例学习Java LinkedHashMap类及其操作。

Java集合框架的LinkedHashMap类提供了Map接口的哈希表和链表实现。

LinkedHashMap继承了HashMap类，以将其条目存储在哈希表中。它在内部在所有条目之间维护一个双链列表，以对条目进行排序。

创建一个LinkedHashMap

为了创建双向链表，我们必须先导入java.util.LinkedHashMap包。导入程序包后，可以使用以下方法在Java中创建双向链表。

//LinkedHashMap的初始容量为8，负载因子为0.6
LinkedHashMap<Key, Value> numbers = new LinkedHashMap<>(8, 0.6f);

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

Ici,

• Clé - Identifiant unique utilisé pour associer chaque élément (valeur) du map

• Value - Les éléments associés aux clés du map

Attention new LinkedHashMap<>(8,0.6) Cette partie. Ici, le premier paramètre est capacity, le second paramètre est loadFactor.

• capacity -　 La capacité de cette liste circulaire double sens est8. Cela signifie qu'elle peut stocker8Entrées.

• loadFactor- Le facteur de charge de cette liste circulaire double sens est de 0.6. Cela signifie que chaque fois que la table de hachage est pleine6Lorsque le facteur de charge atteint 0%, les entrées seront déplacées vers un nouveau tableau de hachage, dont la taille est deux fois plus grande que l'original.

Capacité et facteur de charge par défaut

Il n'est pas nécessaire de définir la capacité et le facteur de charge pour créer une liste circulaire double sens. Par exemple,

//LinkedHashMap avec une capacité et un facteur de charge par défaut
LinkedHashMap<Key, Value> numbers1　= new LinkedHashMap<>();

Par défaut,

• La capacité de la liste circulaire double sens sera 16

• Le facteur de charge sera 0.75

AttentionNotez que LinkedHashMap classe nous permet également de définir l'ordre des entrées. Par exemple

//LinkedHashMap avec une ordre spécifié
LinkedHashMap<Key, Value> numbers2　= new LinkedHashMap<>(capacity, loadFactor, accessOrder);

Ici, accessOrder est une valeur booléenne. La valeur par défaut est false. Dans ce cas, les entrées de la liste circulaire double sens seront triées par ordre d'insertion.

Cependant, si la valeur de accessOrder est true, les entrées de la liste circulaire double sens seront triées par ordre d'accès le plus récent.

Créer LinkedHashMap à partir d'autres listes circulaires doubles sens

Voici une liste circulaire double sens contenant tous les éléments des autres mappings.

import java.util.LinkedHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un LinkedHashMap contenant des nombres pairs
　　　　　　　　LinkedHashMap<String, Integer> evenNumbers = new LinkedHashMap<>();

　　　　　　　　evenNumbers.put("Two", 
　2);
　　　　　　　　evenNumbers.put("Four", 
　4);
　　　　　　　　System.out.println("LinkedHashMap1: "　+　evenNumbers);

　　　　　　　　//Créer LinkedHashMap à partir d'autres LinkedHashMap
　　　　　　　　LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>(evenNumbers);
　　　　　　　　numbers.put("Trois",　3);
　　　　　　　　System.out.println("LinkedHashMap2: "　+　numbers);
　　　　{}
{}

Résultat de la sortie

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

Les méthodes de LinkedHashMap

Cette classe LinkedHashMap fournit des méthodes pour opérer sur la map.

将元素插入LinkedHashMap

• put() - 将指定的键 /值映射插入到映射中

• putAll() -将指定映射中的所有条目插入此map

• putIfAbsent() -如果map中不存在指定的键，则将指定的键 /值映射插入到map中

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

　　　　　　　　//　使用　put()

　　　　　　　　evenNumbers.put("Two", 
　2);
　　　　　　　　evenNumbers.put("Four", 
　4);
　　　　　　　　System.out.println("原始LinkedHashMap: "
　+　evenNumbers);

　　　　　　　　//　使用　putIfAbsent()

　　　　　　　　evenNumbers.putIfAbsent("Six", 
　6);
　　　　　　　　System.out.println("更新后的LinkedHashMap(): "
　+　evenNumbers);

　　　　　　　　//Creating　LinkedHashMap　of　numbers

　　　　　　　　LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
　　　　　　　　numbers.put("Un",　1);
　　　　　　　　//　使用　putAll()

　　　　　　　　numbers.putAll(evenNumbers);

　　　　　　　　System.out.println("新的LinkedHashMap: "
　+　numbers);
　　　　{}
{}

Résultat de la sortie

原始LinkedHashMap: "
2, Four=
4{}
更新后的LinkedHashMap: "
2, Four=
4, Six=
6{}
新的LinkedHashMap: "
1Deux=2, Four=
4, Six=
6{}

访问LinkedHashMap元素

1.使用entrySet()，keySet()和values()

• entrySet() -返回映射的所有键 /值映射的集合

• keySet() - 返回map所有键的集合

• values() - 返回map所有值的集合

Par exemple,

import java.util.LinkedHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
　　　　　　　　numbers.put("Un",　1);
　　　　　　　　numbers.put("Deux",　2);
　　　　　　　　numbers.put("Trois",　3);
　　　　　　　　System.out.println("LinkedHashMap: ",　+　numbers);
　　　　　　　　//　使用　entrySet()

　　　　　　　　System.out.println("Key"
/Value　映射: "
　+　numbers.entrySet());

　　　　　　　　//　使用　keySet()

　　　　　　　　System.out.println("Keys（键）: "
)　+　numbers.keySet());

　　　　　　　　//　使用　values()

　　　　　　　　System.out.println("Values（值）: "
)　+　numbers.values())
　　　　{}
{}

Résultat de la sortie

LinkedHashMap: {Un=1Deux=2Trois=3{}
Clé/Mapping des valeurs: [Un=1Deux=2Trois=3]
Clés (cles): [Un, Deux, Trois]
Valeurs (valeurs): [1,　2,　3]

2.Utilisation de get() et getOrDefault()

• get() - Retourne la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, elle retourne null.

• getOrDefault() - Retourne la valeur associée à la clé spécifiée. Si la clé n'est pas trouvée, elle retourne 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("Un",　1);
　　　　　　　　numbers.put("Deux",　2);
　　　　　　　　numbers.put("Trois",　3);
　　　　　　　　System.out.println("LinkedHashMap: ",　+　numbers);
　　　　　　　　//　Utilisation de get()
　　　　　　　　int value1　= numbers.get("Trois");
　　　　　　　　System.out.println("Retourne le nombre: ",　+　value1);
　　　　　　　　//　Utilisation de getOrDefault()
　　　　　　　　int value2　= numbers.getOrDefault("Cinq",　5);
　　　　　　　　System.out.println("Retourne le nombre: ",　+　value2);
　　　　{}
{}

Résultat de la sortie

LinkedHashMap: {Un=1Deux=2Trois=3{}
Retourne le nombre:　3
Retourne le nombre:　5

Suppression d'éléments de LinkedHashMap

• remove(key) - Retourne et supprime l'élément associé à la clé spécifiée.

• remove(key, value) - La suppression de l'entrée de la carte n'a lieu que lorsque la clé spécifiée est mappée à la valeur spécifiée et que le booléen est retourné.

Par exemple,

import java.util.LinkedHashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashMap<String, Integer> numbers = new LinkedHashMap<>();
　　　　　　　　numbers.put("Un",　1);
　　　　　　　　numbers.put("Deux",　2);
　　　　　　　　numbers.put("Trois",　3);
　　　　　　　　System.out.println("LinkedHashMap: ",　+　numbers);
　　　　　　　　//Méthode de suppression avec un paramètre
　　　　　　　　int value = numbers.remove("Deux");
　　　　　　　　System.out.println("Valeur supprimée: ",　+　value);
　　　　　　　　//Méthode de suppression avec deux paramètres
　　　　　　　　boolean result = numbers.remove("Trois",　3);
　　　　　　　　System.out.println("Entrée3A-t-il été supprimé ? ",　+　result);
　　　　　　　　System.out.println("LinkedHashMap mis à jour: ",　+　numbers);
　　　　{}
{}

Résultat de la sortie

LinkedHashMap: {Un=1Deux=2Trois=3{}
Deleted value:　2
Entry3Was it deleted? True
Updated LinkedHashMap: {One=1{}

Other methods of LinkedHashMap

Differences between LinkedHashMap and HashMap

Both LinkedHashMap and HashMap implement the Map interface. However, there are some differences between them.

• LinkedHashMap internally maintains a doubly linked list. Therefore, it maintains the insertion order of its elements.

• The LinkedHashMap class requires more storage space than HashMap. This is because LinkedHashMap maintains a linked list internally.

• The performance of LinkedHashMap is slower than HashMap.