La clase java.util.Dictionary en Java es una clase abstracta que representa una colección de pares clave-valor, donde las claves son únicas y se utilizan para acceder a los valores. Era parte del marco de colecciones de Java introducido en Java 1.2, pero ha sido reemplazado en gran medida por la interfaz java.util.Map desde Java 1.2.
La clase Diccionario es una clase abstracta y no se puede crear una instancia directamente. En cambio, proporciona las operaciones básicas para acceder a los pares clave-valor almacenados en la colección, que se implementan mediante su subclase concreta java.util.Hashtable.
La clase Diccionario define los siguientes métodos:
- get(Clave de objeto): devuelve el valor asociado con la clave especificada en el diccionario, o nulo si no se encuentra la clave.
- put (clave de objeto, valor de objeto): inserta un par clave-valor en el diccionario. Si la clave ya existe, su valor correspondiente es
- se reemplaza con el nuevo valor y se devuelve el valor anterior. Si la clave es nueva, se devuelve nulo.
- eliminar (clave de objeto): elimina el par clave-valor asociado con la clave especificada del diccionario y devuelve su valor. Si no se encuentra la clave, se devuelve nulo.
- size(): Devuelve el número de pares clave-valor almacenados en el diccionario.
- isEmpty(): Devuelve verdadero si el diccionario está vacío y falso en caso contrario.
elementos(): Devuelve una enumeración de los valores almacenados en el diccionario. - llaves(): Devuelve una enumeración de las claves almacenadas en el diccionario.
A continuación se muestra un ejemplo del uso de la clase Diccionario:
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));> >}> >}> }> |
>
>Producción
30 35 2 Key: Bob, Value: 30 Key: Charlie, Value: 40>
util.Diccionario es una clase abstracta, que representa una valor clave relación y funciona de manera similar a un mapa. Dada una clave, puede almacenar valores y, cuando sea necesario, puede recuperar el valor utilizando su clave. Por tanto, es una lista de pares clave-valor.
Declaración
public abstract class Dictionary extends Object>
Constructores:
Diccionario() Único constructor.
La clase java.util.Dictionary es una clase en Java que proporciona una estructura de datos clave-valor, similar a la interfaz Map. Era parte del marco de colecciones de Java original y se introdujo en Java 1.0.
Sin embargo, desde entonces la clase Diccionario se ha considerado obsoleta y, en general, se desaconseja su uso. Esto se debe a que fue diseñado antes de la introducción del marco de Colecciones y no implementa la interfaz Mapa, lo que dificulta su uso junto con otras partes del marco.
En general, se recomienda utilizar la interfaz Map o una de sus implementaciones (como HashMap o ConcurrentHashMap) en lugar de la clase Diccionario.
A continuación se muestra un ejemplo de cómo utilizar la clase Diccionario:
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));> >}> >}> }> |
>
>Producción
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Métodos de clase util.Dictionary:
1. put (tecla K, valor V): java.util.Dictionary.put (tecla K, valor V) agrega un par clave-valor al diccionario.
Sintaxis:
public abstract V put(K key, V value) Parameters : ->clave -> valor Retorno: par clave-valor asignado en el diccionario>
2. elementos(): java.util.Diccionario.elementos() devuelve la representación del valor en el diccionario.
Sintaxis:
public abstract Enumeration elements() Parameters : -------- Return : value enumeration in dictionary>
3. get (clave de objeto): java.util.Dictionary.get (clave de objeto) devuelve el valor asignado con la clave argumentada en el diccionario.
Sintaxis:
public abstract V get(Object key) Parameters : key - key whose mapped value we want Return : value mapped with the argumented key>
4. está vacío (): java.util.Dictionary.isEmpty () Comprueba si el diccionario está vacío o no.
Sintaxis:
public abstract boolean isEmpty() Parameters : ------ Return : true, if there is no key-value relation in the dictionary; else false>
5. teclas(): java.util.Dictionary.keys() devuelve la representación clave en el diccionario.
Sintaxis:
public abstract Enumeration keys() Parameters : -------- Return : key enumeration in dictionary>
6. eliminar (clave de objeto): java.util.Dictionary.remove (clave de objeto) elimina el par clave-valor asignado con la clave argumentada.
Sintaxis:
public abstract V remove(Object key) Parameters : key : key to be removed Return : value mapped with the key>
7. tamaño(): java.util.Diccionario.tamaño() devuelve el no. de pares clave-valor en el Diccionario.
Sintaxis:
public abstract int size() Parameters : ------- Return : returns the no. of key-value pairs in the Dictionary>
Java
javascript más cercano
// 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());> >}> }> |
>
>
Producción:
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>
Ventajas de la clase Diccionario:
- Soporte heredado: la clase Diccionario era parte del marco de colecciones de Java original y ha sido parte de Java desde el principio. Esto significa que si tiene un código heredado que usa Diccionario, aún puede usarlo en su nuevo código.
- Fácil de usar: la clase Diccionario es fácil de usar y proporciona una funcionalidad básica de estructura de datos clave-valor, que puede resultar útil para casos sencillos.
Desventajas de la clase Diccionario:
- Obsoleto: la clase Diccionario se considera obsoleta y, en general, se desaconseja su uso. Esto se debe a que fue diseñado antes de la introducción del marco de Colecciones y no implementa la interfaz Mapa, lo que dificulta su uso junto con otras partes del marco.
- Funcionalidad limitada: la clase Diccionario proporciona una funcionalidad básica de estructura de datos clave-valor, pero no proporciona la gama completa de funcionalidades que están disponibles en la interfaz Map y sus implementaciones.
- Sin seguridad de tipos: la clase Diccionario utiliza la clase Objeto para representar claves y valores, lo que puede provocar discrepancias de tipos y errores de tiempo de ejecución.
Libros de referencia:
- Colecciones Java de Maurice Naftalin y Philip Wadler. Este libro proporciona una descripción general completa del marco de las colecciones de Java, incluida la clase Diccionario.
- Java en pocas palabras de David Flanagan. Este libro proporciona una referencia rápida de las características principales de Java, incluida la clase Diccionario.
- Colecciones y genéricos de Java de Maurice Naftalin y Philip Wadler. Este libro proporciona una guía completa sobre genéricos y colecciones en Java, incluida la clase Diccionario.