Interface de carte Java

Interface cartographique Java

Dans ce didacticiel, nous allons découvrir l'interface Java Map et ses méthodes.

Le Map L'interface du framework de collections Java fournit la fonctionnalité de la structure de données de la carte.

Fonctionnement de la carte

En Java, les éléments de Map sont stockés dans clé/valeur paires. Clés sont des valeurs uniques associées à des Valeurs individuelles .

Une carte ne peut pas contenir de clés en double. Et chaque clé est associée à une seule valeur.

Nous pouvons accéder et modifier les valeurs en utilisant les clés qui leur sont associées.

Dans le diagramme ci-dessus, nous avons des valeurs :États-Unis , Brésil , et Espagne . Et nous avons les clés correspondantes :us , br , et es .

Maintenant, nous pouvons accéder à ces valeurs en utilisant leurs clés correspondantes.

Remarque : Le Map l'interface maintient 3 ensembles différents :

le jeu de clés
l'ensemble de valeurs
l'ensemble des associations clé/valeur (mapping).

Par conséquent, nous pouvons accéder aux clés, aux valeurs et aux associations individuellement.

Classes qui implémentent Map

Depuis Map est une interface, nous ne pouvons pas créer d'objets à partir de celle-ci.

Pour utiliser les fonctionnalités du Map interface, nous pouvons utiliser ces classes :

HashMap
EnumMap
LinkedHashMap
WeakHashMap
Carte arborescente

Ces classes sont définies dans le framework des collections et implémentent le Map interface.

Interfaces qui étendent Map

Le Map l'interface est également étendue par ces sous-interfaces :

Carte triée
Carte navigable
Carte simultanée

Comment utiliser Map ?

En Java, il faut importer le java.util.Map package afin d'utiliser Map . Une fois le package importé, voici comment créer une carte.

// Map implementation using HashMap
Map<Key, Value> numbers = new HashMap<>();

Dans le code ci-dessus, nous avons créé un Map numéros nommés . Nous avons utilisé le HashMap classe pour implémenter le Map interface.

Ici,

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

Méthodes de carte

Le Map l'interface inclut toutes les méthodes de la Collection interface. C'est parce que Collection est une super interface de Map .

Outre les méthodes disponibles dans le Collection l'interface, le Map l'interface inclut également les méthodes suivantes :

mettre(K, V) - Insère l'association d'une clé K et une valeur V dans la carte. Si la clé est déjà présente, la nouvelle valeur remplace l'ancienne valeur.
putAll() - Insère toutes les entrées de la carte spécifiée dans cette carte.
putIfAbsent(K, V) - Insère l'association si la clé K n'est pas déjà associé à la valeur V .
obtenir(K) - Renvoie la valeur associée à la clé spécifiée K . Si la clé n'est pas trouvée, elle renvoie null .
getOrDefault(K, defaultValue) - Renvoie la valeur associée à la clé spécifiée K . Si la clé n'est pas trouvée, elle renvoie la defaultValue .
containsKey(K) - Vérifie si la clé spécifiée K est présent ou non sur la carte.
containsValue(V) - Vérifie si la valeur spécifiée V est présent ou non sur la carte.
remplacer(K, V) - Remplacer la valeur de la clé K avec la nouvelle valeur spécifiée V .
remplacer(K, ancienneValeur, nouvelleValeur) - Remplace la valeur de la clé K avec la nouvelle valeur newValue uniquement si la clé K est associé à la valeur oldValue .
supprimer(K) - Supprime l'entrée de la carte représentée par la clé K .
supprimer(K, V) - Supprime l'entrée de la carte qui a la clé K associé à la valeur V .
keySet() - Renvoie un ensemble de toutes les clés présentes dans une carte.
valeurs() - Renvoie un ensemble de toutes les valeurs présentes dans une carte.
entrySet() - Renvoie un ensemble de tous les mappages clé/valeur présents dans une carte.

Implémentation de l'interface cartographique

1. Implémentation de la classe HashMap

import java.util.Map;
import java.util.HashMap;

class Main {

    public static void main(String[] args) {
        // Creating a map using the HashMap
        Map<String, Integer> numbers = new HashMap<>();

        // Insert elements to the map
        numbers.put("One", 1);
        numbers.put("Two", 2);
        System.out.println("Map: " + numbers);

        // Access keys of the map
        System.out.println("Keys: " + numbers.keySet());

        // Access values of the map
        System.out.println("Values: " + numbers.values());

        // Access entries of the map
        System.out.println("Entries: " + numbers.entrySet());

        // Remove Elements from the map
        int value = numbers.remove("Two");
        System.out.println("Removed Value: " + value);
    }
}

Sortie

Map: {One=1, Two=2}
Keys: [One, Two]
Values: [1, 2]
Entries: [One=1, Two=2]
Removed Value: 2

Pour en savoir plus sur HashMap , visitez Java HashMap.

2. Implémentation de la classe TreeMap

import java.util.Map;
import java.util.TreeMap;

class Main {

    public static void main(String[] args) {
        // Creating Map using TreeMap
        Map<String, Integer> values = new TreeMap<>();

        // Insert elements to map
        values.put("Second", 2);
        values.put("First", 1);
        System.out.println("Map using TreeMap: " + values);

        // Replacing the values
        values.replace("First", 11);
        values.replace("Second", 22);
        System.out.println("New Map: " + values);

        // Remove elements from the map
        int removedValue = values.remove("First");
        System.out.println("Removed Value: " + removedValue);
    }
}

Sortie

Map using TreeMap: {First=1, Second=2}
New Map: {First=11, Second=22}
Removed Value: 11

Pour en savoir plus sur TreeMap , visitez Java TreeMap.

Java LinkedBlockingQueue Java HashMap

Java