La classe java.util.Dictionary a Java és una classe abstracta que representa una col·lecció de parells clau-valor, on les claus són úniques i s'utilitzen per accedir als valors. Formava part del Java Collections Framework introduït a Java 1.2, però ha estat substituït en gran part per la interfície java.util.Map des de Java 1.2.
La classe Dictionary és una classe abstracta i no es pot crear una instancia directament. En lloc d'això, proporciona les operacions bàsiques per accedir als parells clau-valor emmagatzemats a la col·lecció, que són implementats per la seva subclasse concreta java.util.Hashtable.
La classe Dictionary defineix els mètodes següents:
- get(clau d'objecte): retorna el valor associat a la clau especificada al diccionari, o null si no es troba la clau.
- put(clau d'objecte, valor de l'objecte): insereix un parell clau-valor al diccionari. Si la clau ja existeix, el seu valor corresponent és
- substituït pel nou valor i es retorna el valor antic. Si la clau és nova, es retorna null.
- remove(clau d'objecte): elimina el parell clau-valor associat a la clau especificada del diccionari i retorna el seu valor. Si no es troba la clau, es retorna null.
- size(): retorna el nombre de parells clau-valor emmagatzemats al diccionari.
- isEmpty(): retorna true si el diccionari està buit i false en cas contrari.
elements(): retorna una enumeració dels valors emmagatzemats al diccionari. - keys(): retorna una enumeració de les claus emmagatzemades al diccionari.
Aquí teniu un exemple d'ús 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));> >}> >}> }> |
>
>Sortida
30 35 2 Key: Bob, Value: 30 Key: Charlie, Value: 40>
util.Diccionari és una classe abstracta, que representa a valor-clau relació i funciona semblant a un mapa. Donada una clau, podeu emmagatzemar valors i, quan sigui necessari, podeu recuperar el valor amb la seva clau. Per tant, és una llista de parells clau-valor.
Declaració
public abstract class Dictionary extends Object>
Constructors:
Diccionari () Constructor únic.
La classe java.util.Dictionary és una classe en Java que proporciona una estructura de dades clau-valor, similar a la interfície Map. Formava part del marc original de Java Collections i es va introduir a Java 1.0.
Tanmateix, des de llavors, la classe de Diccionari s'ha considerat obsoleta i generalment es desaconsella el seu ús. Això es deu al fet que es va dissenyar abans de la introducció del marc de col·leccions i no implementa la interfície Map, cosa que dificulta l'ús conjuntament amb altres parts del marc.
En general, es recomana utilitzar la interfície Map o una de les seves implementacions (com ara HashMap o ConcurrentHashMap) en lloc de la classe Dictionary.
Aquí teniu un exemple de com utilitzar la classe de Diccionari:
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));> >}> >}> }> |
>
>Sortida
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Mètodes d'util.Diccionari Classe:
1. put(clau K, valor V): java.util.Dictionary.put (clau K, valor V) afegeix un parell clau-valor al diccionari.
Sintaxi:
public abstract V put(K key, V value) Parameters : ->clau -> valor Retorn: parell clau-valor assignat al diccionari>
2. elements(): java.util.Dictionary.elements() retorna la representació del valor al diccionari.
Sintaxi:
public abstract Enumeration elements() Parameters : -------- Return : value enumeration in dictionary>
3. get (clau d'objecte): java.util.Dictionary.get (clau d'objecte) retorna el valor que s'assigna amb la clau argumentada al diccionari.
Sintaxi:
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() comprova si el diccionari està buit o no.
Sintaxi:
public abstract boolean isEmpty() Parameters : ------ Return : true, if there is no key-value relation in the dictionary; else false>
5. keys(): java.util.Dictionary.keys() retorna la representació clau al diccionari.
Sintaxi:
public abstract Enumeration keys() Parameters : -------- Return : key enumeration in dictionary>
6. remove (clau d'objecte): java.util.Dictionary.remove (clau d'objecte) elimina el parell clau-valor assignat amb la clau argumentada.
Sintaxi:
public abstract V remove(Object key) Parameters : key : key to be removed Return : value mapped with the key>
7. size(): java.util.Dictionary.size() retorna el núm. de parells clau-valor al Diccionari.
Sintaxi:
public abstract int size() Parameters : ------- Return : returns the no. of key-value pairs in the Dictionary>
Java
com fer-ho a Photoshop
// 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());> >}> }> |
>
>
Sortida:
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>
Avantatges de la classe de diccionari:
- Suport heretat: la classe Dictionary formava part del marc original de Java Collections i forma part de Java des del principi. Això vol dir que si teniu codi heretat que utilitza Diccionari, encara podeu utilitzar-lo al vostre codi nou.
- Fàcil d'utilitzar: la classe de Diccionari és senzill d'utilitzar i proporciona una funcionalitat bàsica d'estructura de dades de valor-clau, que pot ser útil per a casos senzills.
Desavantatges de la classe de diccionari:
- Obsolet: la classe Diccionari es considera obsoleta i generalment es desaconsella el seu ús. Això es deu al fet que es va dissenyar abans de la introducció del marc de col·leccions i no implementa la interfície Map, cosa que dificulta l'ús conjuntament amb altres parts del marc.
- Funcionalitat limitada: la classe Dictionary proporciona una funcionalitat bàsica de l'estructura de dades clau-valor, però no ofereix la gamma completa de funcionalitats disponibles a la interfície Map i les seves implementacions.
- No és segur de tipus: la classe Dictionary utilitza la classe Object per representar tant les claus com els valors, cosa que pot provocar desajustos de tipus i errors en temps d'execució.
Llibres de referència:
- Col·leccions Java de Maurice Naftalin i Philip Wadler. Aquest llibre ofereix una visió general completa del marc de col·leccions de Java, inclosa la classe Dictionary.
- Java en poques paraules de David Flanagan. Aquest llibre proporciona una referència ràpida per a les característiques bàsiques de Java, inclosa la classe Dictionary.
- Java Generics and Collections de Maurice Naftalin i Philip Wadler. Aquest llibre ofereix una guia completa sobre genèrics i col·leccions en Java, inclosa la classe Dictionary.