java map interface tutorial with implementation examples
Ce didacticiel complet sur les cartes Java explique comment créer, initialiser et itérer via des cartes. Vous découvrirez également les méthodes de cartographie et les exemples d'implémentation:
Vous apprendrez à connaître les bases de l'interface de la carte, les méthodes prises en charge par l'interface de la carte et d'autres termes spécifiques liés à l'interface de la carte.
La collection Maps en Java est une collection qui mappe une clé à une valeur. C'est une collection composée de clés et de valeurs. Chaque entrée de la carte se compose d'une clé avec sa valeur correspondante. Les clés sont uniques dans les cartes. Les cartes peuvent être utilisées généralement lorsque nous devons modifier une collection en fonction d'une valeur de clé.
=> Consultez TOUS les didacticiels Java ici.
Ce que vous apprendrez:
- Cartes en Java
- Méthodes cartographiques
- Implémentation de Java Map
- Conclusion
Cartes en Java
La carte en Java fait partie de l'interface java.util.map. L'interface de carte ne fait pas partie de l'interface de collection et c'est la raison pour laquelle les cartes sont différentes des autres collections.
La hiérarchie générale de l'interface de la carte est illustrée ci-dessous.
Comme indiqué ci-dessus, il existe deux interfaces pour implémenter la carte, c'est-à-dire l'interface de la carte et l'interface sortedMap. Il existe trois classes, à savoir HashMap, TreeMap et LinkedHashMap.
Ces types de carte sont décrits ci-dessous:
| Classer | La description | |
|---|---|---|
| supprimer | V remove (clé d'objet) | Supprimer une entrée de carte pour la clé donnée |
| LinkedHashMap | S'étend de la classe HashMap. Cette carte conserve l'ordre d'insertion | |
| HashMap | Implémentez une interface cartographique. Aucune commande n'est maintenue par HashMap. | |
| TreeMap | Implémente à la fois l'interface map et sortedMap. TreeMap maintient un ordre croissant. |
Points à retenir sur les cartes.
- Dans les cartes, chaque clé peut correspondre à une valeur au plus. En outre, il ne peut pas y avoir de clés en double dans les cartes.
- Les implémentations de mappage telles que HashMap et LinkedHashMap autorisent les valeurs de clé et de valeur nulles. Cependant, TreeMap ne le permet pas.
- Une carte ne peut pas être parcourue telle quelle. Par conséquent, pour la traversée, il doit être converti en set en utilisant la méthode keyset () ou entrySet ().
Créer une carte en Java
Pour créer une carte en Java, nous devons d'abord inclure l'interface dans notre programme. Nous pouvons utiliser l'une des instructions suivantes dans le programme pour importer la fonctionnalité de carte.
import java.util.*; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.TreeMap; Nous devons instancier une implémentation concrète de la carte car il s'agit d'une interface.
Les instructions suivantes créent une carte en Java.
Map hash_map = new HashMap(); Map tree_map = new TreeMap(); Les instructions ci-dessus créeront des cartes avec des spécifications par défaut.
Nous pouvons également créer des cartes génériques spécifiant les types de clé et de valeur.
Map myMap = new HashMap(); La définition ci-dessus aura des clés de type chaîne et des objets comme valeurs.
Initialiser une carte en Java
Il peut être initialisé à l'aide des méthodes suivantes:
# 1) Utilisation des collections
La classe Java Collections a des méthodes d'usine qui peuvent être utilisées pour initialiser des collections, y compris des cartes.
Certaines méthodes utilisées pour initialiser la carte sont les suivantes:
(1) Collections.EmptyMap ()
Collections.EmptyMap () renvoie une carte sérialisable et immuable qui est vide. Par exemple, la ligne de code suivante,
Map myMap = Collections.EMPTY_MAP; Cela créera une carte vide. La méthode ci-dessus peut lancer un 'avertissement d'affectation non vérifiée' et nous pouvons donc également utiliser la forme de type sécurisé comme suit.
Map myMap = Collections.emptyMap (); (2) Collections.unModifiableMap ()
La méthode unModifiableMap () prend une autre carte comme argument et crée une vue non modifiable de la carte d'origine.
Map myMap = Collections.EMPTY_MAP; Map map_unmodifiable = Collections.unmodifiableMap (myMap); (3) Collections.singletonMap ()
La classe Collections fournit également une méthode de fabrique «singletonMap ()» qui crée une mappe de singleton immuable n'ayant qu'une seule entrée.
Map singleton_map = Collections.singletonMap('CHN', 'Beijing'); # 2) Utilisation de Java 8
Nous pouvons obtenir un flux de données à partir des méthodes API de flux Java 8 et construire des cartes à l'aide de collecteurs.
Certaines des méthodes pour construire des cartes sont:
(1) Collectors.toMap ()
Nous collectons un flux puis utilisons la méthode Collectors.toMap () pour construire une carte.
Map map = Stream.of(new String()(){{'USA', 'Washington'}, {'United Kingdom', 'London'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); L'instruction ci-dessus crée une carte à partir du flux Java 8.
(2) Collectors.collectingAndThen ()
En cela, nous adaptons la méthode toMap () qui permet au collecteur de produire une carte immuable à l'aide de la méthode collectAndThen ().
Map immutableMap = Stream.of(new String()(){ {'USA', 'Washington'}, {'United Kingdom', 'London”} }).collect(Collectors.collectingAndThen(Collectors.toMap(p -> p (0), p -> p(1)), Collections::unmodifiableMap)); # 3) Utilisation de la méthode put de l'interface cartographique
La méthode put () de l'interface de carte peut être utilisée pour attribuer des valeurs initiales aux cartes.
# 4) Utilisation de l'initialisation à double accolade
La technique «initialisation à double accolade» crée une classe interne. Cette classe est anonyme et contient un initialiseur d'instance. Cette technique n'est pas recommandée et doit être évitée car elle peut entraîner des fuites de mémoire ou des problèmes de sérialisation.
Le programme ci-dessous montre les différentes méthodes d'initialisation d'une carte évoquées ci-dessus.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //using Collections //create an empty map Map emptymap = Collections.EMPTY_MAP; //create unmodifiable map using Collections Map unmodifiableMap = Collections.unmodifiableMap(emptymap); System.out.println('unmodifiableMap map values:' + unmodifiableMap); //singleton map Map singleton_map = Collections.singletonMap(10, ' TEN'); System.out.println('
singleton_map Map values:' + singleton_map); //using Java 8 //1. toMap method of collectors class Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('
map_cities values: ' + map_cities); //2. collectingAndThen method Map capitals_Map = Stream.of(new String()(){ {'MAH', 'Mumbai'}, {'GOA', 'Panaji'}, {'KAR', 'Bangaluru'} }).collect(Collectors.collectingAndThen (Collectors.toMap(p -> p(0), p -> p(1)), Collections::unmodifiableMap)); System.out.println('
capitals_Map values: ' + capitals_Map); //double brace initialization Map country_map = new HashMap(); country_map.put('USA', 'Washington'); country_map.put('UK', 'London'); country_map.put('IND', 'Delhi'); country_map.put('GER', 'Berlin'); System.out.println('
Map values:' + country_map); } }Production:
unmodifiableMap map values: {}
singleton_map Valeurs de la carte: {10 = TEN}
Valeurs de map_cities: {CH = Chennai, DL = New Delhi, MH = Mumbai}
valeurs de capitals_Map: {MAH = Mumbai, GOA = Panaji, KAR = Bangaluru}
Valeurs de la carte: {USA = Washington, GER = Berlin, UK = Londres, IND = Delhi}
Itérer sur la carte en Java et imprimer la carte
Nous pouvons parcourir la carte de la même manière que nous parcourons les autres collections. En plus de parcourir les entrées de la carte, nous pouvons également parcourir uniquement les clés ou uniquement les valeurs de la carte. Notez que pour parcourir une carte, elle doit d'abord être convertie en position définie.
Les méthodes suivantes sont utilisées pour parcourir les entrées de la carte.
Utilisation d'itérateur d'entrée
Dans cette méthode, nous obtenons un itérateur d'entrée à partir d'un ensemble d'entrées. Ensuite, en utilisant les méthodes getKey et getValue, nous récupérons la paire clé-valeur pour chaque entrée de carte.
Le programme suivant montre l'utilisation d'un itérateur d'entrée.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); //transform map to set Set entries = map_cities.entrySet(); //declare an iterator Iterator iterator = entries.iterator(); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate and print key and value pairs. while(iterator.hasNext()) { Map.Entry entry = iterator.next(); System.out.println(' ' + entry.getKey() + ' ' +entry.getValue()); } } } Production:
Les entrées de la carte sont:
VALEUR CLÉ
CH Chennai
DL New Delhi
MH Bombay
Dans le programme ci-dessus, nous obtenons un itérateur d'entrée à partir de la carte en utilisant la méthode entrySet. Ensuite, nous parcourons la carte en utilisant la méthode hasNext () de l'itérateur d'entrée et imprimons la paire clé-valeur.
Utilisation d'une entrée pour chaque boucle
Ici, nous parcourons le entrySet en utilisant la boucle for-each et l'implémentation est indiquée ci-dessous.
import java.util.*; import java.util.stream.*; import java.util.stream.Collectors; public class Main { public static void main(String args()) { //use toMap method of collectors class to populate the map Map map_cities = Stream.of(new String()(){ {'MH', 'Mumbai'}, {'CH', 'Chennai'}, {'DL', 'New Delhi'} }).collect(Collectors.toMap(p -> p(0), p -> p(1))); System.out.println('The map entries are:'); System.out.println(' KEY VALUE'); //iterate using for each over entry set and print key and value pairs. for(Map.Entry entry : map_cities.entrySet()){ System.out.println(' ' + entry.getKey() + ' ' +entry.getValue()); } } } Production:
Les entrées de la carte sont:
VALEUR CLÉ
CH Chennai
DL New Delhi
MH Bombay
Méthodes cartographiques
L'interface de carte en Java prend en charge diverses opérations similaires à celles prises en charge par d'autres collections. Dans cette section, nous discuterons des différentes méthodes fournies par Map API en Java. La portée de ce didacticiel étant limitée à l'introduction d'une interface cartographique en général, nous ne décrirons pas ces méthodes.
Nous discuterons de ces méthodes en détail tout en discutant des classes d'interface de carte.
Le tableau suivant répertorie toutes les méthodes fournies par Map API.
| Nom de la méthode | Prototype de méthode | La description |
|---|---|---|
| avoir | V get (clé d'objet) | Renvoie l'objet ou la valeur de la clé donnée |
| mettre | V put (clé d'objet, valeur d'objet) | Insérer une entrée de valeur-clé dans la carte |
| Met tout | void putAll (Carte carte) | Insérez des entrées de carte données dans la carte. En d'autres termes, copie ou clone une carte. |
| keySet | Définir keySet () | Renvoie la vue d'ensemble de la carte. |
| entrySet | Ensemble | Les retours définissent la vue d'une carte donnée |
| valeurs | Valeurs de collection () | Renvoie la vue de collection des valeurs de la carte. |
| Taille | taille int () | Renvoie le nombre d'entrées dans la carte |
| dégager | vide clair () | Efface la carte |
| est vide | booléen isEmpty () | Vérifie si la carte est vide et renvoie true si oui. |
| contientValeur | boolean containsValue (valeur de l'objet) | Renvoie true si la carte contient la valeur égale à la valeur donnée |
| contientKey | boolean containsKey (clé d'objet) | Renvoie true si une clé donnée existe dans la carte |
| équivaut à | booléen égal (objet o) | Compare l'objet spécifié o avec la carte |
| hashCode | int hashCode () | renvoie le code de hachage de la carte |
| pour chaque | void forEach (action BiConsumer) | Exécute l'action donnée pour chaque entrée de la carte |
| getOrDefault | V getOrDefault (clé d'objet, V defaultValue) | Renvoie la valeur spécifiée pour la clé donnée ou sa valeur par défaut si la clé n'est pas présente |
| supprimer | boolean remove (clé d'objet, valeur d'objet) | Supprime les clés et les valeurs spécifiées |
| remplacer | V remplacer (clé K, valeur V) | Remplace la clé donnée par la valeur spécifiée |
| remplacer | boolean replace (clé K, V oldValue, V newValue) | Remplace l'ancienne valeur par une nouvelle valeur pour une clé donnée |
| remplace tout | void replaceAll (fonction BiFonction) | Appelle une fonction donnée pour remplacer toutes les entrées de la carte |
| putIfAbsent | V putIfAbsent (clé K, valeur V) | Insère la clé donnée, valeur uniquement si elle n'est pas déjà présente |
| calculer | Calcul V (touche K, fonction de remappage BiFonction) | Calcule le mappage pour la clé et la valeur spécifiées en fonction de la fonction de mappage. |
| computeIfAbsent | V computeIfAbsent (touche K, fonction de mappage de fonction) | Calculez la valeur de la clé donnée à l'aide de la fonction de mappage si elle n'est pas déjà présente. |
| computeIfPresent | V computeIfPresent (touche K, fonction de remappage BiFonction) | Calcule le nouveau mappage pour la clé donnée avec la fonction de remappage donnée si la valeur de clé est déjà présente |
| aller | Fusion V (clé K, valeur V, fonction de remappage BiFonction) | Associe une clé donnée à la valeur si elle n'est pas déjà associée ou est associée à la valeur nulle. |
Toutes les méthodes ci-dessus sont prises en charge par l'interface de la carte. Notez que les méthodes qui apparaissent grisées sont les nouvelles méthodes qui ont été incluses dans Java 8.
Implémentation de Java Map
Le programme suivant implémente un exemple de carte en Java. Ici, nous utilisons la plupart des méthodes décrites ci-dessus.
L'exemple montre diverses opérations get, put et set.
import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class Main { public static void main(String() args) { //create a map Map country_map = new HashMap(); //assign values to the map country_map.put('IND', 'India'); country_map.put('SL', 'Srilanka'); country_map.put('CHN', 'China'); country_map.put('KOR', 'Korea'); country_map.put(null, 'Z'); // null key country_map.put('XX', null); // null value String value = country_map.get('CHN'); // get System.out.println('Key = CHN, Value : ' + value); value = country_map.getOrDefault('XX', 'Default Value'); //getOrDefault System.out.println('
Key = XX, Value : ' + value); boolean keyExists = country_map.containsKey(null); //containsKey boolean valueExists = country_map.containsValue('Z'); //containsValue System.out.println('
null keyExists : ' + keyExists + ', null valueExists= ' + valueExists); Set entrySet = country_map.entrySet(); //entrySet System.out.println('
entry set for the country_map: ' + entrySet); System.out.println('
Size of country_map : ' + country_map.size()); //size Map data_map = new HashMap(); data_map.putAll(country_map); //putAll System.out.println('
data_map mapped to country_map : ' + data_map); String nullKeyValue = data_map.remove(null); //remove System.out.println('
null key value for data_map : ' + nullKeyValue); System.out.println('
data_map after removing null key = ' + data_map); Set keySet = country_map.keySet(); //keySet System.out.println('
data map keys : ' + keySet); Collection values = country_map.values(); //values System.out.println('
data map values : ' + values); country_map.clear(); //clear System.out.println('
data map after clear operation, is empty :' + country_map.isEmpty()); } } Production:
Clé = CHN, valeur: Chine
Clé = XX, valeur: null
null keyExists: true, null valueExists = true
jeu d'entrées pour country_map: (null = Z, XX = null, CHN = Chine, SL = Srilanka, IND = Inde, KOR = Corée)
Taille de country_map: 6
data_map mappé à country_map: {null = Z, XX = null, CHN = Chine, SL = Srilanka, IND = Inde, KOR = Kore
à}
valeur de clé nulle pour data_map: Z
data_map après suppression de la clé nulle = {XX = null, CHN = Chine, SL = Srilanka, IND = Inde, KOR = Corée}
clés de mappage de données: (null, XX, CHN, SL, IND, KOR)
valeurs de la carte de données: (Z, null, Chine, Srilanka, Inde, Corée)
la carte de données après l'opération d'effacement, est vide: vrai
Trier une carte en Java
Comme une carte se compose de paires clé-valeur, nous pouvons trier la carte sur des clés ou des valeurs.
Dans cette section, nous allons trier une carte sur les clés et les valeurs.
Trier par clé
Pour trier une carte sur les clés, nous pouvons utiliser un treemap. Le treemap trie les clés automatiquement. Le programme Java ci-dessous convertit une carte en un treemap et affiche les clés triées.
import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class Main { public static void main(String() args) { //declare and initialize a map Map country_map = new HashMap(); country_map.put('I', 'India'); country_map.put('C', 'China'); country_map.put('A', 'America'); country_map.put('D', 'Denmark'); country_map.put('X', 'Hongkong'); //print original map System.out.println('Original Unsorted Map: '); display_map(country_map); System.out.println('
Map sorted by Key: '); //convert map to treemap and display it in which keys are auto sorted Map treecountry = new TreeMap(country_map); display_map(treecountry); } public static void display_map(Map map) { //obtain entry iterator and display key value pairs of map for (Map.Entry entry : map.entrySet()) { System.out.println(' ' + entry.getKey() + ' ' + entry.getValue()); } } }Production:
Carte originale non triée:
Une Amérique
C Chine
D Danemark
X Hongkong
I Inde
Carte triée par clé:
Une Amérique
C Chine
D Danemark
I Inde
X Hongkong
Le programme ci-dessus crée une carte constituée d'un seul code alphabétique sous forme de clés et de noms de pays sous forme de valeurs. Tout d'abord, nous affichons la carte d'origine qui n'est pas triée. Ensuite, nous convertissons la carte en un treemap qui trie automatiquement les clés. Enfin, nous affichons le treemap trié sur les clés.
Trier par valeur
Pour trier une carte en fonction de valeurs, nous convertissons d'abord la carte en une liste. Ensuite, nous trions cette liste à l'aide de la méthode Collections.sort () qui utilise un comparateur pour comparer les valeurs et les organiser dans un ordre spécifique.
Une fois la liste triée, les entrées de la liste liée sont à nouveau copiées sur la carte qui nous donne la carte triée.
Le programme Java suivant illustre le tri d'une carte en fonction de sa valeur. Le programme utilise LinkedHashMap qui est passé à la fonction de tri. Dans la fonction de tri, il est converti en liste chaînée et trié. Après le tri, il est reconverti en LinkedHashMap.
C ++ convertir char en int
import java.util.*; public class Main { public static void main(String() args) { //define and initialize a map LinkedHashMap capitals_map = new LinkedHashMap(); capitals_map.put('NEP', 'Kathmandu'); capitals_map.put('IND', 'New Delhi'); capitals_map.put('USA', 'Washington'); capitals_map.put('UK', 'London'); capitals_map.put('AUS', 'Canberra'); //print original map System.out.println('Original unsorted map: '); System.out.println(capitals_map); //call sortMap method Map sorted_Map = sortMap(capitals_map); //print the sorted map System.out.println('
Map sorted on value : '); System.out.println(' Key Value '); for (Map.Entry entry : sorted_Map.entrySet()) { System.out.println(' ' + entry.getKey()+ ' ' + entry.getValue()); } } public static LinkedHashMap sortMap(LinkedHashMap linked_map) { //create a linkedlist from LinkedHashMap List capital_List = new LinkedList(linked_map.entrySet()); //sort the LinkedList Collections.sort(capital_List, (o1, o2) -> o1.getValue().compareTo(o2.getValue())); //Create LinkedHashMap from linkedlist and return it LinkedHashMap finalMap = new LinkedHashMap(); for (Map.Entry entry : capital_List) { finalMap.put(entry.getKey(), entry.getValue()); } return finalMap; } } Production:
Carte originale non triée:
{NEP = Katmandou, IND = New Delhi, USA = Washington, UK = Londres, AUS = Canberra
Carte triée par valeur:
Valeur clé
DE Canberra
NEP Katmandou
Royaume-Uni Londres
IND New Delhi
États-Unis Washington
Carte simultanée en Java
Un concurrentMap est une interface qui hérite de l'interface java.util.map. L'interface concurrentMap a été introduite pour la première fois dans JDK 1.5 et fournit une carte qui gère les accès simultanés.
L'interface concurrentMap fait partie du package java.util.concurrent.
Le programme Java suivant illustre la concurrenteMap en Java.
import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } } import java.util.concurrent.*; class Main { public static void main(String() args) { //create and initialize concurrentHashMap ConcurrentHashMap m = new ConcurrentHashMap(); m.put(100, 'Red'); m.put(101, 'Green'); m.put(102, 'Blue'); System.out.println('
Initial Concurrent Map : ' + m); //add a key using putIfAbsent method; key=103 is absent so its added m.putIfAbsent(103, 'Purple'); System.out.println('
After adding absent key 103 : ' + m); m.remove(101, 'Green'); // remove key = 101 System.out.println('
Concurrent Map after removing 101:' + m); m.putIfAbsent(101, 'Brown'); // again add key = 101 since its absent System.out.println('
Add absent key 101:' + m); m.replace(101, 'Brown', 'Green'); // replace value for key = 101 with 'Green' System.out.println('
Replace value at key 101:' + m); } }Production:
Carte initiale simultanée: {100 = rouge, 101 = vert, 102 = bleu}
Après avoir ajouté la clé absente 103: {100 = Rouge, 101 = Vert, 102 = Bleu, 103 = Violet}
Carte simultanée après suppression de 101: {100 = rouge, 102 = bleu, 103 = violet}
Ajouter la clé absente 101: {100 = Rouge, 101 = Marron, 102 = Bleu, 103 = Violet}
Remplacer la valeur à la clé 101: {100 = rouge, 101 = vert, 102 = bleu, 103 = violet}
Carte synchronisée en Java
Une carte synchronisée est une carte qui est thread-safe et qui est sauvegardée par une carte donnée. En Java, la mappe synchronisée est obtenue à l'aide de la méthode synchronizedMap () de la classe java.util.Collections. Cette méthode renvoie une carte synchronisée pour une carte donnée.
Cette mappe synchronisée renvoyée est utilisée pour accéder à la mappe de sauvegarde pour obtenir un accès série.
La déclaration générale de la méthode synchronizedMap () est:
C ++ nombre aléatoire entre
public static Map synchronizedMap(Map m) où m => est la carte sauvegardée.
Comme déjà mentionné, cette méthode renvoie la vue synchronisée de la carte m.
Le programme Java ci-dessous est un exemple de carte synchronisée.
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a map Map int_map = new HashMap(); int_map.put(1, 10); int_map.put(2, 20); int_map.put(3, 30); int_map.put(4, 40); int_map.put(5, 50); //print the map System.out.println('Original (backed) Map: ' + int_map); //obtain synchronized map Map sync_map = Collections.synchronizedMap(int_map); //remove an element from the map int_map.remove(3, 30); //print the altered map System.out.println('
Synchronized map after remove(3, 30):' + sync_map); } } Production:
Carte d'origine (à dos): {1 = 10, 2 = 20, 3 = 30, 4 = 40, 5 = 50}
Carte synchronisée après suppression (3, 30): {1 = 10, 2 = 20, 4 = 40, 5 = 50}
Carte statique en Java
Une carte statique en Java est une carte qui est déclarée statique tout comme une variable statique. En déclarant une carte statique, elle devient une variable de classe accessible sans utiliser l'objet.
Il existe deux approches pour créer et initialiser une carte statique en Java.
# 1) Utilisation d'une variable statique
Ici, nous créons une variable de carte statique et l'instancions avec la déclaration.
Cette approche est illustrée dans le programme Java suivant.
import java.util.*; class Main { //declare a static map variable and initialize it with declaration private static final Map myMap = new HashMap(){ { put(1, 'India'); put(2, 'Portugal'); put(3, 'Germany'); } }; public static void main(String() args) { //print the map System.out.println('Static map using static map variable:'); System.out.println(myMap); } }Production:
Carte statique utilisant une variable de carte statique:
{1 = Inde, 2 = Portugal, 3 = Allemagne}
# 2) Utilisation du bloc statique
En cela, nous créons une variable de carte statique. Ensuite, nous créons un bloc statique et à l'intérieur de ce bloc statique, nous initialisons la variable de carte.
Le programme ci-dessous le démontre.
import java.util.*; class Main { // Declare the static map private static Map map; // declare a static block and initialize static map static { map = new HashMap(); map.put(1, 'Red'); map.put(2, 'Green'); map.put(3, 'Blue'); } public static void main(String() args) { System.out.println('Static Map using static block:'); System.out.println(map); } } Production:
Carte statique utilisant un bloc statique:
{1 = rouge, 2 = vert, 3 = bleu}
Conversion de la liste en carte
Dans cette section, nous discuterons des méthodes pour convertir la liste en carte.
Les deux méthodes comprennent:
Méthode traditionnelle
Dans la méthode traditionnelle, chaque élément de liste est copié sur la carte à l'aide d'une boucle for-each.
Cette implémentation est illustrée ci-dessous:
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a list List colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Brown'); colorsList.add('White'); System.out.println('The given list: ' + colorsList); //declare a map Map map = new HashMap(); //initial Id(key) int i=1; //assign each list element to the map for (String color : colorsList) { map.put(i, color); i++; } //print the map System.out.println('Map generated from List:' + map); } } Production:
La liste donnée: (Rouge, Vert, Bleu, Marron, Blanc)
Carte générée à partir de la liste: {1 = rouge, 2 = vert, 3 = bleu, 4 = marron, 5 = blanc}
Liste à mapper dans Java 8
Nous pouvons également utiliser la méthode Java 8 Collectors.mapOf () qui convertira la liste donnée en une carte.
Le programme ci-dessous le démontre.
import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; import java.util.stream.Collectors; // class for list class Subject { //sub_id => map key private Integer sub_id; // sub_name => map value private String sub_name; // Subject constructor public Subject(Integer sub_id, String sub_name) { // initialize sub_id and sub_name this.sub_id = sub_id; this.sub_name = sub_name; } // return sub_id public Integer getSub_Id() { return sub_id; } // return sub_name public String getSub_Name() { return sub_name; } } public class Main { public static void main(String() args) { // create a list and add values to the list List sub_list = new ArrayList(); sub_list.add(new Subject(1, 'Abacus')); sub_list.add(new Subject(2, 'Maths')); sub_list.add(new Subject(3, 'Physics')); sub_list.add(new Subject(3, 'Chemistry')); //use Java 8 Collectors.toMap() method to create a map and assign list elements to it LinkedHashMap sub_map = sub_list.stream() .collect( Collectors.toMap(Subject::getSub_Id, Subject::getSub_Name,(x, y) -> x + ', ' + y, LinkedHashMap::new)); //print the map System.out.println('Map obtained from list : ' + sub_map); } } Production:
Carte obtenue à partir de la liste: {1 = Abacus, 2 = Maths, 3 = Physics, Chemistry}
Dans ce programme, nous avons une classe Subject qui agit comme une classe de liste. La classe Subject a deux champs, à savoir sub_id et sub_name. Nous avons des méthodes pour lire les valeurs de champ de la classe. Dans la fonction principale, nous créons des objets de cette classe et construisons une liste.
Cette liste est ensuite convertie en carte à l'aide de la méthode Collectors.MapOf qui prend les éléments un par un. Il prend également le sub_Id comme clé de la carte. Enfin, la mappe qui a sub_Id comme clé et Sub_Name comme valeur est générée.
Convertir la carte en chaîne en Java
Une collection de cartes peut être convertie en chaîne en utilisant deux approches:
Utilisation de StringBuilder
Ici, nous créons un objet StringBuilder, puis copions les paires clé-valeur de la carte dans l'objet StringBuilder. Ensuite, nous convertissons l'objet StringBuilder en une chaîne.
Le programme ci-dessous montre le code Java pour convertir la carte en chaîne.
import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); //create a StringBuilder object to store string StringBuilder map_String = new StringBuilder('{'); //append key-value pair of map to StringBuilder object for (Integer key : numberNames.keySet()) { map_String.append(key + '=' + numberNames.get(key) + ', '); } map_String.delete(map_String.length()-2, map_String.length()).append('}'); //print the string from StringBuilder System.out.println('
The string representation of map:'); System.out.println(map_String.toString()); } }Production:
La carte donnée: {20 = vingt, 40 = quarante, 10 = dix, 30 = trente}
La représentation sous forme de chaîne de map:
{20 = vingt, 40 = quarante, 10 = dix, 30 = trente}
Utilisation des flux Java 8
Dans cette méthode, nous créons un flux à partir des clés de la carte, puis nous le convertissons en chaîne.
Le programme donné ci-dessous montre la conversion de la carte en une chaîne à l'aide de flux.
import java.util.*; import java.util.stream.Collectors; public class Main{ public static void main(String() args) { //create and initialize a map Map numberNames = new HashMap(); numberNames.put(10, 'Ten'); numberNames.put(20, 'Twenty'); numberNames.put(30, 'Thirty'); numberNames.put(40, 'Forty'); //print the given map System.out.println('The given map: ' + numberNames); String map_String = numberNames.keySet().stream() .map(key -> key + '=' + numberNames.get(key)) .collect(Collectors.joining(', ', '{', '}')); //print the string System.out.println('
The string representation of map:'); System.out.println(map_String); } }Production:
La carte donnée: {20 = vingt, 40 = quarante, 10 = dix, 30 = trente}
La représentation sous forme de chaîne de map:
{20 = vingt, 40 = quarante, 10 = dix, 30 = trente}
Convertir la carte en liste en Java
Une carte se compose de clés et de valeurs, tandis qu'une liste est une séquence d'éléments individuels. Lors de la conversion de la carte en liste, nous convertissons généralement les clés en une liste de clés et les valeurs en une liste de valeurs.
Le programme Java suivant montre cette conversion.
import java.util.*; public class Main { public static void main(String() args) { //declare a map and initialize it Map color_map = new HashMap(); color_map.put(10, 'red'); color_map.put(20, 'green'); color_map.put(30, 'blue'); color_map.put(40, 'cyan'); color_map.put(50, 'magenta'); //print the list of keys using map.keySet() method System.out.println('List of keys from the given map:'); List key_list = new ArrayList(color_map.keySet()); System.out.println(key_list); //print the list of values using map.values() method System.out.println('
List of values from the given map:'); List val_list = new ArrayList(color_map.values()); System.out.println(val_list); } }Production:
Liste des clés de la carte donnée:
(50, 20, 40, 10, 30)
Liste des valeurs de la carte donnée:
(magenta, vert, cyan, rouge, bleu)
Dictionnaire Vs. Carte en Java
Voyons quelques-unes des principales différences entre un dictionnaire et une carte en Java.
| dictionnaire | Carte |
|---|---|
| Le dictionnaire est une classe abstraite. | La carte est une interface. |
| Les classes et méthodes utilisées par la classe de dictionnaire sont antérieures au framework de collections. | Les classes et méthodes utilisées par les classes de carte font partie du cadre de collecte. |
| Si une classe étend le dictionnaire, elle ne peut étendre aucune autre classe car Java ne prend en charge qu'un seul héritage | La carte est une interface, donc une classe peut hériter de la carte et d'autres interfaces |
| Ancienne implémentation. Presque obsolète dans les nouvelles versions de Java. | L'interface de la carte a remplacé l'implémentation du dictionnaire. |
Questions fréquemment posées
Q # 1) Pourquoi utilisons-nous une interface cartographique en Java?
Répondre: La carte est une interface en Java implémentée par des classes stockant des données sous forme de paires clé-valeur. L'interface de carte fournit des opérations / méthodes qui peuvent être effectuées sur des paires clé-valeur telles que l'insertion, la mise à jour, la suppression, etc.
Q # 2)Que signifie MAP en Java?
Répondre: Une carte en Java représente un mappage d'une clé avec une valeur spécifique. Une carte Java stocke ces paires clé-valeur dans une carte. Nous pouvons rechercher et récupérer la valeur associée à une clé simplement en utilisant la clé dans la carte.
Une carte est implémentée en Java à l'aide d'une interface qui ne fait pas partie de l'interface Collection. Mais la carte est une collection.
Q # 3)Qu'est-ce que MAP get?
Répondre: Le get () est une méthode fournie par une interface de carte en Java qui est utilisée pour récupérer la valeur associée à une clé particulière fournie comme argument de la méthode get (). Si la valeur n'est pas présente, un null est renvoyé.
Q # 4)La carte est-elle une collection?
Répondre: Bien que la carte soit considérée comme une collection en général, elle n'implémente pas d'interface de collection. Certaines des implémentations de map, comme treemap, ne prennent pas en charge les valeurs ou clés nulles.
Q # 5)Quelle est la différence entre set et map?
Répondre: Set est une collection de clés uniquement tandis que la carte est une collection de paires clé-valeur. Bien que l'ensemble n'autorise pas les valeurs nulles, certaines implémentations de carte autorisent les valeurs nulles.
Set n'autorise pas les clés en double. La carte peut autoriser des valeurs en double mais les clés doivent être uniques. Set est généralement utilisé lorsque nous voulons stocker une collection d'éléments uniques. La carte peut être utilisée lorsque nous avons besoin de stocker des données sous la forme de paires clé-valeur.
Conclusion
Dans ce didacticiel, nous avons abordé les bases de l'interface de la carte. Nous avons également vu les différentes méthodes et tous les autres détails liés à l'interface de la carte en Java. Nous avons appris qu'il existe diverses implémentations d'interfaces cartographiques, notamment treemap, hashmap, etc.
Dans nos prochains didacticiels, nous aborderons cette implémentation de carte plus en détail.
=> Visitez ici pour apprendre Java à partir de zéro.
lecture recommandée
- Qu'est-ce qu'un HashMap en Java?
- TreeMap en Java - Tutoriel avec des exemples de TreeMap Java
- LinkedHashMap en Java - Exemple et implémentation LinkedHashMap
- Définir l'interface en Java: didacticiel sur le jeu Java avec des exemples
- Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques
- Tutoriel Java Stack: Implémentation de classe Stack avec des exemples
- Tutoriel de réflexion Java avec des exemples
- Jagged Array In Java - Tutoriel avec des exemples