La classe java.util.Dictionary in Java è una classe astratta che rappresenta una raccolta di coppie chiave-valore, in cui le chiavi sono univoche e vengono utilizzate per accedere ai valori. Faceva parte del Java Collections Framework introdotto in Java 1.2 ma è stato in gran parte sostituito dall'interfaccia java.util.Map a partire da Java 1.2.
La classe Dictionary è una classe astratta e non è possibile istanziarla direttamente. Fornisce invece le operazioni di base per accedere alle coppie chiave-valore archiviate nella raccolta, che sono implementate dalla sua sottoclasse concreta java.util.Hashtable.
La classe Dictionary definisce i seguenti metodi:
- get(Chiave oggetto): restituisce il valore associato alla chiave specificata nel dizionario o null se la chiave non viene trovata.
- put(Chiave oggetto, Valore oggetto): inserisce una coppia chiave-valore nel dizionario. Se la chiave esiste già, il suo valore corrispondente è
- sostituito con il nuovo valore e viene restituito il vecchio valore. Se la chiave è nuova, viene restituito null.
- rimuovi(Chiave oggetto): rimuove dal dizionario la coppia chiave-valore associata alla chiave specificata e ne restituisce il valore. Se la chiave non viene trovata, viene restituito null.
- size(): restituisce il numero di coppie chiave-valore memorizzate nel dizionario.
- isEmpty(): restituisce vero se il dizionario è vuoto e falso altrimenti.
elements(): Restituisce un'enumerazione dei valori memorizzati nel dizionario. - keys(): Restituisce un'enumerazione delle chiavi memorizzate nel dizionario.
Ecco un esempio di utilizzo della classe Dictionary:
Giava
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));> >}> >}> }> |
>
>Produzione
30 35 2 Key: Bob, Value: 30 Key: Charlie, Value: 40>
util.Dizionario è una classe astratta, che rappresenta a valore-chiave relazione e funziona in modo simile a una mappa. Data una chiave è possibile memorizzare valori e, quando necessario, recuperare il valore utilizzando la relativa chiave. Pertanto, è un elenco di coppie chiave-valore.
Dichiarazione
public abstract class Dictionary extends Object>
Costruttori:
Dizionario() Unico costruttore.
La classe java.util.Dictionary è una classe in Java che fornisce una struttura dati chiave-valore, simile all'interfaccia Map. Faceva parte del framework Java Collections originale ed è stato introdotto in Java 1.0.
Tuttavia, da allora la classe Dictionary è stata considerata obsoleta e il suo utilizzo è generalmente scoraggiato. Questo perché è stato progettato prima dell'introduzione del framework Collections e non implementa l'interfaccia Map, il che ne rende difficile l'utilizzo insieme ad altre parti del framework.
In generale, si consiglia di utilizzare l'interfaccia Map o una delle sue implementazioni (come HashMap o ConcurrentHashMap) invece della classe Dictionary.
Ecco un esempio di come utilizzare la classe Dictionary:
Giava
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));> >}> >}> }> |
>
>Produzione
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Metodi della classe util.Dictionary:
1. put(chiave K, valore V): java.util.Dictionary.put(chiave K, valore V) aggiunge la coppia chiave-valore al dizionario.
Sintassi:
public abstract V put(K key, V value) Parameters : ->chiave -> valore Restituisce: coppia chiave-valore mappata nel dizionario>
2. elementi(): java.util.Dictionary.elements() restituisce la rappresentazione del valore nel dizionario.
Sintassi:
public abstract Enumeration elements() Parameters : -------- Return : value enumeration in dictionary>
3. get (chiave oggetto): java.util.Dictionary.get (chiave oggetto) restituisce il valore mappato con la chiave argomentata nel dizionario.
Sintassi:
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() controlla se il dizionario è vuoto o meno.
Sintassi:
public abstract boolean isEmpty() Parameters : ------ Return : true, if there is no key-value relation in the dictionary; else false>
5. chiavi(): java.util.Dictionary.keys() restituisce la rappresentazione della chiave nel dizionario.
Sintassi:
public abstract Enumeration keys() Parameters : -------- Return : key enumeration in dictionary>
6. rimuovi (chiave oggetto): java.util.Dictionary.remove (chiave oggetto) rimuove la coppia chiave-valore mappata con la chiave argomentata.
Sintassi:
public abstract V remove(Object key) Parameters : key : key to be removed Return : value mapped with the key>
7. dimensione(): java.util.Dictionary.size() restituisce il n. di coppie chiave-valore nel dizionario.
Sintassi:
public abstract int size() Parameters : ------- Return : returns the no. of key-value pairs in the Dictionary>
Giava
file .tif
// 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());> >}> }> |
>
>
Produzione:
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>
Vantaggi della classe Dizionario:
- Supporto legacy: la classe Dictionary faceva parte del framework Java Collections originale ed è stata parte di Java sin dall'inizio. Ciò significa che se disponi di codice legacy che utilizza il dizionario, puoi comunque utilizzarlo nel nuovo codice.
- Semplice da usare: la classe Dictionary è semplice da usare e fornisce funzionalità di base della struttura dati chiave-valore, che possono essere utili per casi semplici.
Svantaggi della classe Dictionary:
- Obsoleto: la classe Dictionary è considerata obsoleta e il suo utilizzo è generalmente sconsigliato. Questo perché è stato progettato prima dell'introduzione del framework Collections e non implementa l'interfaccia Map, il che ne rende difficile l'utilizzo insieme ad altre parti del framework.
- Funzionalità limitate: la classe Dictionary fornisce funzionalità di base della struttura dati chiave-valore, ma non fornisce la gamma completa di funzionalità disponibili nell'interfaccia Map e nelle relative implementazioni.
- Non indipendente dai tipi: la classe Dictionary utilizza la classe Object per rappresentare sia chiavi che valori, il che può portare a mancate corrispondenze di tipo ed errori di runtime.
Libri di riferimento:
- Collezioni Java di Maurice Naftalin e Philip Wadler. Questo libro fornisce una panoramica completa del framework Java Collections, inclusa la classe Dictionary.
- Java in poche parole di David Flanagan. Questo libro fornisce un rapido riferimento alle funzionalità principali di Java, inclusa la classe Dictionary.
- Java Generics e raccolte di Maurice Naftalin e Philip Wadler. Questo libro fornisce una guida completa ai generici e alle raccolte in Java, inclusa la classe Dictionary.