La classe java.util.Dictionary en Java est une classe abstraite qui représente une collection de paires clé-valeur, où les clés sont uniques et sont utilisées pour accéder aux valeurs. Il faisait partie du Java Collections Framework introduit dans Java 1.2 mais a été largement remplacé par l'interface java.util.Map depuis Java 1.2.
La classe Dictionary est une classe abstraite et ne peut pas être instanciée directement. Au lieu de cela, il fournit les opérations de base pour accéder aux paires clé-valeur stockées dans la collection, qui sont implémentées par sa sous-classe concrète java.util.Hashtable.
La classe Dictionary définit les méthodes suivantes :
- get(Object key) : renvoie la valeur associée à la clé spécifiée dans le dictionnaire, ou null si la clé n'est pas trouvée.
- put(Object key, Object value) : insère une paire clé-valeur dans le dictionnaire. Si la clé existe déjà, sa valeur correspondante est
- remplacé par la nouvelle valeur et l'ancienne valeur est renvoyée. Si la clé est nouvelle, null est renvoyé.
- Remove (Object Key) : supprime la paire clé-valeur associée à la clé spécifiée du dictionnaire et renvoie sa valeur. Si la clé n'est pas trouvée, null est renvoyé.
- size() : renvoie le nombre de paires clé-valeur stockées dans le dictionnaire.
- isEmpty() : renvoie true si le dictionnaire est vide et false sinon.
elements() : renvoie une énumération des valeurs stockées dans le dictionnaire. - keys() : renvoie une énumération des clés stockées dans le dictionnaire.
Voici un exemple d’utilisation de la classe Dictionary :
Java
import> java.util.Dictionary;> import> java.util.Enumeration;> import> java.util.Hashtable;> public> class> DictionaryExample {> >public> static> void> main(String[] args)> >{> >Dictionary dict=>new> Hashtable();> >dict.put(>'Alice'>,>25>);> >dict.put(>'Bob'>,>30>);> >dict.put(>'Charlie'>,>35>);> >System.out.println(dict.get(>'Bob'>));>// 30> >int> oldValue = dict.put(>'Charlie'>,>40>);> >System.out.println(oldValue);>// 35> >dict.remove(>'Alice'>);> >System.out.println(dict.size());>// 2> >Enumeration k = dict.keys();> >while> (k.hasMoreElements()) {> >String key = k.nextElement();> >System.out.println(>'Key: '> + key +>', Value: '> >+ dict.get(key));> >}> >}> }> |
>
>Sortir
30 35 2 Key: Bob, Value: 30 Key: Charlie, Value: 40>
util.Dictionnaire est une classe abstraite, représentant un valeur clé relation et fonctionne comme une carte. Étant donné une clé, vous pouvez stocker des valeurs et, si nécessaire, récupérer la valeur à l'aide de sa clé. Il s’agit donc d’une liste de paires clé-valeur.
Déclaration
public abstract class Dictionary extends Object>
Constructeurs :
Dictionnaire() Constructeur unique.
La classe java.util.Dictionary est une classe en Java qui fournit une structure de données clé-valeur, similaire à l'interface Map. Il faisait partie du framework Java Collections d'origine et a été introduit dans Java 1.0.
Cependant, la classe Dictionary a depuis été considérée comme obsolète et son utilisation est généralement déconseillée. En effet, il a été conçu avant l'introduction du framework Collections et n'implémente pas l'interface Map, ce qui rend difficile son utilisation avec d'autres parties du framework.
En général, il est recommandé d'utiliser l'interface Map ou l'une de ses implémentations (telle que HashMap ou ConcurrentHashMap) au lieu de la classe Dictionary.
Voici un exemple d’utilisation de la classe Dictionary :
Java
import> java.util.Dictionary;> import> java.util.Enumeration;> import> java.util.Hashtable;> public> class> Main {> >public> static> void> main(String[] args) {> >Dictionary dictionary =>new> Hashtable();> >// Adding elements to the dictionary> >dictionary.put(>'A'>,>1>);> >dictionary.put(>'B'>,>2>);> >dictionary.put(>'C'>,>3>);> >// Getting values from the dictionary> >int> valueA = dictionary.get(>'A'>);> >System.out.println(>'Value of A: '> + valueA);> >// Removing elements from the dictionary> >dictionary.remove(>'B'>);> >// Enumerating the elements of the dictionary> >Enumeration keys = dictionary.keys();> >while> (keys.hasMoreElements()) {> >String key = keys.nextElement();> >System.out.println(>'Key: '> + key +>', Value: '> + dictionary.get(key));> >}> >}> }> |
>
>Sortir
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Méthodes de la classe util.Dictionary :
1. put (clé K, valeur V) : java.util.Dictionary.put (clé K, valeur V) ajoute une paire clé-valeur au dictionnaire.
Syntaxe :
public abstract V put(K key, V value) Parameters : ->key -> value Return : paire clé-valeur mappée dans le dictionnaire>
2. éléments() : java.util.Dictionary.elements() renvoie la représentation de la valeur dans le dictionnaire.
Syntaxe :
public abstract Enumeration elements() Parameters : -------- Return : value enumeration in dictionary>
3. get (clé d'objet) : java.util.Dictionary.get (clé d'objet) renvoie la valeur mappée avec la clé argumentée dans le dictionnaire.
Syntaxe :
public abstract V get(Object key) Parameters : key - key whose mapped value we want Return : value mapped with the argumented key>
4. isEmpty() : java.util.Dictionary.isEmpty() vérifie si le dictionnaire est vide ou non.
Syntaxe :
public abstract boolean isEmpty() Parameters : ------ Return : true, if there is no key-value relation in the dictionary; else false>
5. clés() : java.util.Dictionary.keys() renvoie la représentation clé dans le dictionnaire.
Syntaxe :
public abstract Enumeration keys() Parameters : -------- Return : key enumeration in dictionary>
6. supprimer (clé d'objet) : java.util.Dictionary.remove (clé d'objet) supprime la paire clé-valeur mappée avec la clé argumentée.
Syntaxe :
public abstract V remove(Object key) Parameters : key : key to be removed Return : value mapped with the key>
7. size() : java.util.Dictionary.size() renvoie le numéro. de paires clé-valeur dans le dictionnaire.
Syntaxe :
public abstract int size() Parameters : ------- Return : returns the no. of key-value pairs in the Dictionary>
Java
code de nombre aléatoire c
// Java Program explaining util.Dictionary class Methods> // put(), elements(), get(), isEmpty(), keys()> // remove(), size()> import> java.util.*;> public> class> New_Class> {> >public> static> void> main(String[] args)> >{> >// Initializing a Dictionary> >Dictionary geek =>new> Hashtable();> >// put() method> >geek.put('>123>', 'Code');> >geek.put('>456>', 'Program');> >// elements() method :> >for> (Enumeration i = geek.elements(); i.hasMoreElements();)> >{> >System.out.println('Value in Dictionary : ' + i.nextElement());> >}> >// get() method :> >System.out.println('
Value at key =>6> : ' + geek.get('>6>'));> >System.out.println('Value at key =>456> : ' + geek.get('>123>'));> >// isEmpty() method :> >System.out.println('
There is no key-value pair : ' + geek.isEmpty() + '
');> >// keys() method :> >for> (Enumeration k = geek.keys(); k.hasMoreElements();)> >{> >System.out.println('Keys in Dictionary : ' + k.nextElement());> >}> >// remove() method :> >System.out.println('
Remove : ' + geek.remove('>123>'));> >System.out.println('Check the value of removed key : ' + geek.get('>123>'));> >System.out.println('
Size of Dictionary : ' + geek.size());> >}> }> |
>
>
Sortir:
Value in Dictionary : Code Value in Dictionary : Program Value at key = 6 : null Value at key = 456 : Code There is no key-value pair : false Keys in Dictionary : 123 Keys in Dictionary : 456 Remove : Code Check the value of removed key : null Size of Dictionary : 1>
Avantages de la classe Dictionnaire :
- Prise en charge héritée : la classe Dictionary faisait partie du framework Java Collections d'origine et fait partie de Java depuis le début. Cela signifie que si vous disposez d’un ancien code qui utilise Dictionary, vous pouvez toujours l’utiliser dans votre nouveau code.
- Simple à utiliser : la classe Dictionary est simple à utiliser et fournit des fonctionnalités de base de structure de données clé-valeur, qui peuvent être utiles pour des cas simples.
Inconvénients de la classe Dictionnaire :
- Obsolète : La classe Dictionary est considérée comme obsolète et son utilisation est généralement déconseillée. En effet, il a été conçu avant l'introduction du framework Collections et n'implémente pas l'interface Map, ce qui rend difficile son utilisation avec d'autres parties du framework.
- Fonctionnalité limitée : la classe Dictionary fournit des fonctionnalités de base de structure de données clé-valeur, mais ne fournit pas la gamme complète de fonctionnalités disponibles dans l'interface Map et ses implémentations.
- Non sécurisé : la classe Dictionary utilise la classe Object pour représenter à la fois les clés et les valeurs, ce qui peut entraîner des incompatibilités de type et des erreurs d'exécution.
Livres de référence:
- Collections Java de Maurice Naftalin et Philip Wadler. Ce livre fournit une présentation complète du framework Java Collections, y compris la classe Dictionary.
- Java en bref par David Flanagan. Ce livre fournit une référence rapide sur les fonctionnalités principales de Java, y compris la classe Dictionary.
- Génériques et collections Java par Maurice Naftalin et Philip Wadler. Ce livre fournit un guide complet sur les génériques et les collections en Java, y compris la classe Dictionary.