En Java, Map Interface est présente dans le package java.util et représente un mappage entre une clé et une valeur. L'interface Java Map n'est pas un sous-type de Interface de collecte . Par conséquent, il se comporte un peu différemment des autres types de collections. Une carte contient des clés uniques.
Geeks, le brainstorming aurait dû être pourquoi et quand utiliser Maps.
Les cartes sont parfaites pour le mappage d’associations clé-valeur tel que les dictionnaires. Les cartes sont utilisées pour effectuer des recherches par clés ou lorsque quelqu'un souhaite récupérer et mettre à jour des éléments par clés. Certains scénarios courants sont les suivants :
- Une carte des codes d'erreur et leurs descriptions.
- Une carte des codes postaux et des villes.
- Une cartographie des managers et des salariés. Chaque manager (clé) est associé à une liste d'employés (valeur) qu'il gère.
- Une carte des classes et des étudiants. Chaque classe (clé) est associée à une liste d'élèves (valeur).
Création d'objets cartographiques
Puisque Map est un interface , les objets de type map ne peuvent pas être créés. Nous avons toujours besoin d'une classe qui étend cette carte afin de créer un objet. Et aussi, après l'introduction de Génériques dans Java 1.5, il est possible de restreindre le type d'objet pouvant être stocké dans la Map.
Syntaxe: Définition d'une carte de type sécurisé
Map hm = new HashMap(); // Obj is the type of the object to be stored in Map>
Caractéristiques d'une interface cartographique
- Une carte ne peut pas contenir de clés en double et chaque clé peut correspondre à au plus une valeur. Certaines implémentations autorisent les clés nulles et les valeurs nulles comme HashMap et LinkedHashMap , mais certaines n'aiment pas le ArbreCarte .
- L'ordre d'une carte dépend des implémentations spécifiques. Par exemple, ArbreCarte et LinkedHashMap ont des ordres prévisibles, contrairement à HashMap.
- Il existe deux interfaces pour implémenter Map en Java. Il s'agit de Map et SortedMap et de trois classes : HashMap, TreeMap et LinkedHashMap.
Méthodes dans l'interface de carte Java
| Méthode | Action effectuée |
|---|---|
| clair() | Cette méthode est utilisée dans Java Map Interface pour effacer et supprimer tous les éléments ou mappages d'une collection Map spécifiée. |
| contientClé (Objet) | Cette méthode est utilisée dans Map Interface en Java pour vérifier si une clé particulière est mappée ou non dans la carte. Il prend l'élément clé comme paramètre et renvoie True si cet élément est mappé dans la carte. |
| contientValeur(Objet) | Cette méthode est utilisée dans Map Interface pour vérifier si une valeur particulière est mappée par une ou plusieurs clés dans la Map. Il prend la valeur comme paramètre et renvoie True si cette valeur est mappée par l'une des clés de la carte. |
| jeu d'entrées() | Cette méthode est utilisée dans Map Interface en Java pour créer un ensemble des mêmes éléments contenus dans la carte. Il renvoie essentiellement une vue définie de la carte ou nous pouvons créer un nouvel ensemble et y stocker les éléments de la carte. |
| est égal à (Objet) | Cette méthode est utilisée dans Java Map Interface pour vérifier l'égalité entre deux cartes. Il vérifie si les éléments d'une carte passés en paramètre sont égaux ou non aux éléments de cette carte. |
| obtenir (Objet) | Cette méthode est utilisée pour récupérer ou récupérer la valeur mappée par une clé particulière mentionnée dans le paramètre. Il renvoie NULL lorsque la carte ne contient aucun mappage de ce type pour la clé. |
| code de hachage() | Cette méthode est utilisée dans Map Interface pour générer un hashCode pour la carte donnée contenant des clés et des valeurs. |
| est vide() | Cette méthode est utilisée pour vérifier si une carte contient une entrée pour les paires clé et valeur. Si aucun mappage n’existe, cela renvoie vrai. |
| jeu de clés() | Cette méthode est utilisée dans Map Interface pour renvoyer une vue définie des clés contenues dans cette carte. L'ensemble s'appuie sur la carte, de sorte que les modifications apportées à la carte sont reflétées dans l'ensemble, et vice versa. |
| mettre(Objet, Objet) | Cette méthode est utilisée dans Java Map Interface pour associer la valeur spécifiée à la clé spécifiée dans cette carte. |
| putAll (Carte) | Cette méthode est utilisée dans Map Interface en Java pour copier tous les mappages de la carte spécifiée vers cette carte. |
| supprimer (Objet) | Cette méthode est utilisée dans Map Interface pour supprimer le mappage d’une clé de cette carte si elle est présente dans la carte. |
| taille() | Cette méthode est utilisée pour renvoyer le nombre de paires clé/valeur disponibles dans la carte. |
| valeurs() | Cette méthode est utilisée dans Java Map Interface pour créer une collection à partir des valeurs de la carte. Il renvoie essentiellement une vue Collection des valeurs dans HashMap. |
| getOrDefault (clé objet, V valeur par défaut) | Renvoie la valeur à laquelle la clé spécifiée est mappée, ou defaultValue si cette carte ne contient aucun mappage pour la clé. |
| fusionner (clé K, valeur V, fonction de remapping BiFunction) | Si la clé spécifiée n'est pas déjà associée à une valeur ou est associée à null, associez-la à la valeur non nulle donnée. |
| putIfAbsent (clé K, valeur V) | Si la clé spécifiée n'est pas déjà associée à une valeur (ou est mappée à null), l'associe à la valeur donnée et renvoie null, sinon renvoie la valeur associée actuelle. |
Exemple:
Java
// Java Program to Demonstrate> // Working of Map interface> > // Importing required classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an empty HashMap> >Map hm> >=>new> HashMap();> > >// Inserting pairs in above Map> >// using put() method> >hm.put(>'a'>,>new> Integer(>100>));> >hm.put(>'b'>,>new> Integer(>200>));> >hm.put(>'c'>,>new> Integer(>300>));> >hm.put(>'d'>,>new> Integer(>400>));> > >// Traversing through Map using for-each loop> >for> (Map.Entry me :> >hm.entrySet()) {> > >// Printing keys> >System.out.print(me.getKey() +>':'>);> >System.out.println(me.getValue());> >}> >}> }> |
>
>Sortir:
a:100 b:200 c:300 d:400>
Les classes qui implémentent l'interface Map sont représentées dans le média ci-dessous et décrites plus loin comme suit :
1. Carte de hachage
Carte de hachage fait partie de la collection Java depuis Java 1.2. Il fournit l'implémentation de base de l'interface Map de Java. Il stocke les données dans des paires (Clé, Valeur). Pour accéder à une valeur, il faut connaître sa clé. Cette classe utilise une technique appelée Java
// Java Program to illustrate the Hashmap Class> > // Importing required classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an empty HashMap> >Map map =>new> HashMap();> > >// Inserting entries in the Map> >// using put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> > >// Iterating over Map> >for> (Map.Entry e : map.entrySet())> > >// Printing key-value pairs> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
>
qu'est-ce que c'est
>Sortir
vaibhav 20 vishal 10 sachin 30>
2. LinkedHashMap
LinkedHashMap est comme HashMap avec la fonctionnalité supplémentaire de conserver un ordre des éléments qui y sont insérés. HashMap offre l'avantage d'une insertion, d'une recherche et d'une suppression rapides, mais il n'a jamais conservé la trace et l'ordre d'insertion fournis par LinkedHashMap lorsque les éléments sont accessibles dans leur ordre d'insertion. Voyons comment créer un objet cartographique à l'aide de cette classe.
Exemple
Java
// Java Program to Illustrate the LinkedHashmap Class> > // Importing required classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an empty LinkedHashMap> >Map map =>new> LinkedHashMap();> > >// Inserting pair entries in above Map> >// using put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> > >// Iterating over Map> >for> (Map.Entry e : map.entrySet())> > >// Printing key-value pairs> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
>
>Sortir
java pendant la condition
vishal 10 sachin 30 vaibhav 20>
3. ArbreMap
Le TreeMap en Java est utilisé pour implémenter l'interface Map et NavigableMap avec la classe abstraite. La carte est triée selon l'ordre naturel de ses clés, ou par un comparateur fourni au moment de la création de la carte, selon le constructeur utilisé. Cela s'avère être un moyen efficace de trier et de stocker les paires clé-valeur. L'ordre de stockage maintenu par le treemap doit être cohérent avec les égaux, comme n'importe quelle autre carte triée, quels que soient les comparateurs explicites. Voyons comment créer un objet cartographique à l'aide de cette classe.
Exemple
Java
// Java Program to Illustrate TreeMap Class> > // Importing required classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an empty TreeMap> >Map map =>new> TreeMap();> > >// Inserting custom elements in the Map> >// using put() method> >map.put(>'vishal'>,>10>);> >map.put(>'sachin'>,>30>);> >map.put(>'vaibhav'>,>20>);> > >// Iterating over Map using for each loop> >for> (Map.Entry e : map.entrySet())> > >// Printing key-value pairs> >System.out.println(e.getKey() +>' '> >+ e.getValue());> >}> }> |
>
>Sortir
sachin 30 vaibhav 20 vishal 10>
Exécution d'opérations à l'aide Interface cartographique et Classe HashMap
Puisque Map est une interface, elle ne peut être utilisée qu'avec une classe qui implémente cette interface. Voyons maintenant comment effectuer quelques opérations fréquemment utilisées sur une carte en utilisant le largement utilisé Classe HashMap . Et aussi, après l'introduction de Génériques dans Java 1.5, il est possible de restreindre le type d'objet pouvant être stocké dans la carte.
1. Ajout d'éléments
Afin d'ajouter un élément à la carte, nous pouvons utiliser la méthode put() . Cependant, l'ordre d'insertion n'est pas conservé dans le hashmap. En interne, pour chaque élément, un hachage distinct est généré et les éléments sont indexés en fonction de ce hachage pour le rendre plus efficace.
Exemple
Java
quel est le système de fichiers Linux
// Java program to demonstrate> // the working of Map interface> > import> java.util.*;> class> GFG {> >public> static> void> main(String args[])> >{> >// Default Initialization of a> >// Map> >Map hm1 =>new> HashMap();> > >// Initialization of a Map> >// using Generics> >Map hm2> >=>new> HashMap();> > >// Inserting the Elements> >hm1.put(>1>,>'Geeks'>);> >hm1.put(>2>,>'For'>);> >hm1.put(>3>,>'Geeks'>);> > >hm2.put(>new> Integer(>1>),>'Geeks'>);> >hm2.put(>new> Integer(>2>),>'For'>);> >hm2.put(>new> Integer(>3>),>'Geeks'>);> > >System.out.println(hm1);> >System.out.println(hm2);> >}> }> |
>
>Sortir
{1=Geeks, 2=For, 3=Geeks} {1=Geeks, 2=For, 3=Geeks}> 2. Changer d'élément
Après avoir ajouté les éléments, si nous souhaitons modifier l'élément, cela peut être fait en ajoutant à nouveau l'élément avec la méthode put(). Étant donné que les éléments de la carte sont indexés à l'aide des clés, la valeur de la clé peut être modifiée en insérant simplement la valeur mise à jour pour la clé pour laquelle nous souhaitons modifier.
Exemple
Java
// Java program to demonstrate> // the working of Map interface> > import> java.util.*;> class> GFG {> >public> static> void> main(String args[])> >{> > >// Initialization of a Map> >// using Generics> >Map hm1> >=>new> HashMap();> > >// Inserting the Elements> >hm1.put(>new> Integer(>1>),>'Geeks'>);> >hm1.put(>new> Integer(>2>),>'Geeks'>);> >hm1.put(>new> Integer(>3>),>'Geeks'>);> > >System.out.println(>'Initial Map '> + hm1);> > >hm1.put(>new> Integer(>2>),>'For'>);> > >System.out.println(>'Updated Map '> + hm1);> >}> }> |
>
>Sortir
Initial Map {1=Geeks, 2=Geeks, 3=Geeks} Updated Map {1=Geeks, 2=For, 3=Geeks}> 3. Suppression d'éléments
Afin de supprimer un élément de la Map, nous pouvons utiliser la méthode remove() . Cette méthode prend la valeur de la clé et supprime le mappage d'une clé de cette carte si elle est présente dans la carte.
Exemple
Java
// Java program to demonstrate> // the working of Map interface> > import> java.util.*;> class> GFG {> > >public> static> void> main(String args[])> >{> > >// Initialization of a Map> >// using Generics> >Map hm1> >=>new> HashMap();> > >// Inserting the Elements> >hm1.put(>new> Integer(>1>),>'Geeks'>);> >hm1.put(>new> Integer(>2>),>'For'>);> >hm1.put(>new> Integer(>3>),>'Geeks'>);> >hm1.put(>new> Integer(>4>),>'For'>);> > >// Initial Map> >System.out.println(hm1);> > >hm1.remove(>new> Integer(>4>));> > >// Final Map> >System.out.println(hm1);> >}> }> |
les algorithmes de tri fusionnent le tri
>
>Sortir
{1=Geeks, 2=For, 3=Geeks, 4=For} {1=Geeks, 2=For, 3=Geeks}> 4. Itérer sur la carte
Il existe plusieurs façons de parcourir la carte. La méthode la plus connue consiste à utiliser une boucle for-each et à obtenir les clés. La valeur de la clé est trouvée à l'aide de la méthode getValue().
Exemple
Java
// Java program to demonstrate> // the working of Map interface> > import> java.util.*;> class> GFG {> >public> static> void> main(String args[])> >{> > >// Initialization of a Map> >// using Generics> >Map hm1> >=>new> HashMap();> > >// Inserting the Elements> >hm1.put(>new> Integer(>1>),>'Geeks'>);> >hm1.put(>new> Integer(>2>),>'For'>);> >hm1.put(>new> Integer(>3>),>'Geeks'>);> > >for> (Map.Entry mapElement : hm1.entrySet()) {> >int> key = (>int>)mapElement.getKey();> > >// Finding the value> >String value = (String)mapElement.getValue();> > >System.out.println(key +>' : '> + value);> >}> >}> }> |
>
>Sortir
1 : Geeks 2 : For 3 : Geeks>
5. Comptez l'occurrence des nombres à l'aide de Hashmap
Dans ce code, nous utilisons putIfAbsent( ) avec Collections.fréquence() compter l'occurrence exacte des nombres. Dans de nombreux programmes, vous devez compter l’occurrence d’un chiffre ou d’une lettre particulière. Vous utilisez l’approche suivante pour résoudre ces types de problèmes
Java
// Java program to Count the Occurrence> // of numbers using Hashmap> import> java.util.*;> > class> HelloWorld {> >public> static> void> main(String[] args)> >{> >int> a[] = {>1>,>13>,>4>,>1>,>41>,>31>,>31>,>4>,>13>,>2> };> > >// put all elements in arraylist> >ArrayList aa =>new> ArrayList();> >for> (>int> i =>0>; i aa.add(a[i]); } HashMap h = new HashMap(); // counting occurrence of numbers for (int i = 0; i h.putIfAbsent(aa.get(i), Collections.frequency( aa, aa.get(i))); } System.out.println(h); } }> |
>
>Sortir
{1=2, 2=1, 4=2, 41=1, 13=2, 31=2}> FAQ dans l'interface cartographique Java
T1. Qu’est-ce qu’une interface cartographique en Java ?
Répondre:
La carte contient des paires clé-valeur, où nous accédons aux éléments de la carte à l'aide de valeurs clés.
Q2. Quels sont les types d’interfaces cartographiques en Java ?
Répondre:
Il existe 3 implémentations d'interface cartographique HashMap, LinkedHashMap et TreeMap.