Java LinkedHashMap

En Java, LinkedHashMap est une implémentation de linkedlist depuis l'interface Map. Il est similaire à HashMap, où une fonctionnalité supplémentaire est incluse qui maintient l'ordre des éléments qui y sont insérés. Même si HashMap permet une insertion, une suppression et une recherche rapides, l'ordre d'insertion des éléments n'est pas conservé.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Fonctionnalités de Java LinkedHashMap

En plus de cela, plusieurs autres fonctionnalités sont également incluses dans LinkedHashMap.

• Il se compose uniquement d'éléments uniques.
• Il peut contenir une seule clé nulle et plusieurs valeurs nulles.
• L'ordre d'insertion est maintenu.
• Étend la classe HashMap.
• Les valeurs présentes sont basées sur la clé.
• Non synchronisé.
• 16 est la capacité initiale par défaut
• Le facteur de charge est de 0,75.

Syntaxe :

LinkedHashMap<Integer, String> obj = new LinkedHashMap<Integer, String>();

Ici, obj est l'objet du LinkedHashMap créé.

Une fois l'objet LinkedHashMap créé, il sera utilisé pour ajouter des éléments à la carte, comme indiqué ci-dessous.

obj.put(11, "Victor");
obj.put(33, "Shyla");
obj.put(14, "Nancy");
obj.put(100, "Kuffi");
obj.put(23, "Princy");
obj.put(37, "Chamm");

Constructeurs

Vous trouverez ci-dessous les constructeurs d'un LinkedHashMap :

1. LinkedHashMap() : Une instance LinkedHashMap vide sera créée avec l'ordre basé sur l'insertion, le facteur de charge de 0,75 et la capacité initiale par défaut de 16.

2. LinkedHashMap(int initialCapacity) : Une instance LinkedHashMap vide sera créée avec l'ordre basé sur l'insertion, le facteur de charge de 0,75 et la capacité initiale spécifiée.

3. LinkedHashMap(int initialCapacity, float loadFactor) : Une instance LinkedHashMap vide sera créée avec l'ordre basé sur l'insertion, le facteur de charge spécifié et la capacité initiale.

4. LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) : Une instance LinkedHashMap vide sera créée avec le facteur de charge, l'ordre d'accès et la capacité initiale spécifiés.

5. LinkedHashMap(Map m) : Une instance LinkedHashMap sera créée avec l'ordre basé sur l'insertion et les mappages basés sur la carte mentionnée.

Méthodes

Voici les méthodes couramment utilisées dans LinkedHashMap.

1. clear() : Chaque mappage de la carte sera supprimé.

2. boolean containKey(Object key) : Si la carte contient un mappage vers une ou plusieurs clés de la valeur mentionnée, true sera renvoyé.

3. boolean containValue (Object key) : Si la carte contient un mappage avec au moins une clé, true sera renvoyé.

4. Object get (Object key) : La valeur du mappage de la clé mentionnée sera renvoyée.

5. isEmpty() : S'il n'y a aucun mappage de paire clé-valeur, true sera renvoyé.

6. size() : Le nombre de paires clé-valeur disponibles dans la carte sera renvoyé.

7. Object Remove (Object Key) : La valeur du mappage de la clé mentionnée sera supprimée.

8. boolean removeEldestEntry(Map.Entry eldest): Si l'entrée la plus ancienne peut être supprimée, true sera renvoyé.

Exemples de Java LinkedHashMap

Vous trouverez ci-dessous les exemples de Java LinkedHashMap :

Exemple n°1

Programme Java pour créer un LinkedHashMap simple.

Code :

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
//class begins here
public class LinkedHashMapExample {
//main method
public static void main(String args[]) {
// create a LinkedHashMap
LinkedHashMap<Integer, String> obj = new LinkedHashMap<Integer, String>();
//Adding key-value pair 1
obj.put(11, "Anna");
//Adding key-value pair 2
obj.put(33, "Adam");
//Adding key-value pair 3
obj.put(14, "Iza");
//Adding key-value pair 4
obj.put(23, "Norah");
//Adding key-value pair 5
obj.put(100, "Denan");
// create an entry set
Set s = obj.entrySet();
// Display the elements
Iterator itr = s.iterator();
//iterate each element
while(itr.hasNext()) {
//create an object for map.entry
Map.Entry mp = (Map.Entry)itr.next();
//print each element
System.out.print("Key in the LinkedHashMap is : "+ mp.getKey() +
" and it's corresponding value is: "+mp.getValue()+" \n");
}
}
}

Sortie :

Dans ce programme, un LinkedHashMap est créé en premier. Après cela, des éléments y sont ajoutés avec des paires clé-valeur. Une fois terminé, un ensemble d’entrées est créé. De plus, afin d'imprimer tous les éléments du LinkedHashMap, un itérateur est créé. En itérant chaque élément, il est imprimé et affiché comme indiqué dans l'exemple de sortie.

Exemple n°2

Programme Java pour supprimer la paire clé-valeur de la carte.

Code :

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
//class begins here
public class LinkedHashMapExample {
//main method
public static void main(String args[]) {
// create a LinkedHashMap
LinkedHashMap<Integer, String> obj = new LinkedHashMap<Integer, String>();
//Adding key-value pair 1
obj.put(11, "Victor");
//Adding key-value pair 2
obj.put(33, "Shyla");
//Adding key-value pair 3
obj.put(14, "Nancy");
//Adding key-value pair 4
obj.put(100, "Kuffi");
//Adding key-value pair 5
obj.put(23, "Princy");
//Adding key-value pair 6
obj.put(37, "Chamm");
System.out.print("Before removal, LinkedHashMap is: "+obj+"\n");
//remove the elements with keys 100 and 37
obj.remove(100);
obj.remove(37);
System.out.print("After removal, LinkedHashMap is: "+obj);
}
}

Sortie :

Dans ce programme également, un LinkedHashMap est créé en premier. Après cela, des éléments y sont ajoutés avec des paires clé-valeur. Une fois terminé, LinkedHashMap est imprimé. Ensuite, deux paires clé-valeur sont supprimées de la carte à l'aide de la méthode remove(). Après cela, une fois de plus, la carte est imprimée et affichée comme indiqué dans l'exemple de sortie.

Exemple #3

Programme Java pour imprimer des paires clé-valeur dans la carte en fonction de l'ordre d'accès.

Code :

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
//class begins here
public class LinkedHashMapExample {
//main method
public static void main(String args[]) {
// create a LinkedHashMap with third paramter set access order
LinkedHashMap<Integer, String> obj = new LinkedHashMap<Integer, String>(2, .75f, true);
//Adding key-value pair 1
obj.put(11, "Victor");
//Adding key-value pair 2
obj.put(33, "Shyla");
//Adding key-value pair 3
obj.put(14, "Nancy");
//Adding key-value pair 4
obj.put(100, "Kuffi");
//Adding key-value pair 5
obj.put(23, "Princy");
//Adding key-value pair 6
obj.put(37, "Chamm");
//Access the pair 33
obj.get(33);
//Access the pair 11
obj.get(11);
System.out.print("LinkedHashMap with access order is: "+obj);
}
}

Sortie :

Ici, dans ce programme également, un LinkedHashMap est créé en premier. Après cela, des éléments y sont ajoutés avec des paires clé-valeur. Une fois terminé, on accède aux éléments avec les clés 33 et 11. Ensuite, la carte est imprimée et affichée comme indiqué dans l’exemple de sortie. On voit que les éléments auxquels on accède se trouvent à la fin de la carte.

Conclusion

Presque tous les détails sur Java LinkedHashMap, tels que la syntaxe, les constructeurs, les méthodes et les exemples, sont explorés en détail dans cet article. De plus, il identifie également la principale différence entre LinkedHashMap et HashMap.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!