Die Klasse java.util.Dictionary in Java ist eine abstrakte Klasse, die eine Sammlung von Schlüssel-Wert-Paaren darstellt, wobei Schlüssel eindeutig sind und für den Zugriff auf die Werte verwendet werden. Es war Teil des Java Collections Framework, das in Java 1.2 eingeführt wurde, wurde aber seit Java 1.2 weitgehend durch die java.util.Map-Schnittstelle ersetzt.
Die Dictionary-Klasse ist eine abstrakte Klasse und kann nicht direkt instanziiert werden. Stattdessen stellt es die grundlegenden Operationen für den Zugriff auf die in der Sammlung gespeicherten Schlüssel-Wert-Paare bereit, die von seiner konkreten Unterklasse java.util.Hashtable implementiert werden.
Die Dictionary-Klasse definiert die folgenden Methoden:
- get(Objektschlüssel): Gibt den Wert zurück, der dem angegebenen Schlüssel im Wörterbuch zugeordnet ist, oder null, wenn der Schlüssel nicht gefunden wird.
- put(Objektschlüssel, Objektwert): Fügt ein Schlüssel-Wert-Paar in das Wörterbuch ein. Wenn der Schlüssel bereits vorhanden ist, lautet sein entsprechender Wert
- durch den neuen Wert ersetzt und der alte Wert zurückgegeben. Wenn der Schlüssel neu ist, wird null zurückgegeben.
- Remove(Objektschlüssel): Entfernt das mit dem angegebenen Schlüssel verknüpfte Schlüssel-Wert-Paar aus dem Wörterbuch und gibt seinen Wert zurück. Wenn der Schlüssel nicht gefunden wird, wird null zurückgegeben.
- size(): Gibt die Anzahl der im Wörterbuch gespeicherten Schlüssel-Wert-Paare zurück.
- isEmpty(): Gibt true zurück, wenn das Wörterbuch leer ist, andernfalls false.
elements(): Gibt eine Aufzählung der im Wörterbuch gespeicherten Werte zurück. - keys(): Gibt eine Aufzählung der im Wörterbuch gespeicherten Schlüssel zurück.
Hier ist ein Beispiel für die Verwendung der Dictionary-Klasse:
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));> >}> >}> }> |
>
>Ausgabe
30 35 2 Key: Bob, Value: 30 Key: Charlie, Value: 40>
util.Dictionary ist eine abstrakte Klasse, die a darstellt Schlüsselwert Beziehung und funktioniert ähnlich wie eine Karte. Mit einem Schlüssel können Sie Werte speichern und bei Bedarf mit dem Schlüssel wieder abrufen. Es handelt sich also um eine Liste von Schlüssel-Wert-Paaren.
Erklärung
public abstract class Dictionary extends Object>
Konstrukteure:
Wörterbuch() Alleiniger Konstrukteur.
Die Klasse java.util.Dictionary ist eine Klasse in Java, die eine Schlüsselwert-Datenstruktur bereitstellt, ähnlich der Map-Schnittstelle. Es war Teil des ursprünglichen Java Collections-Frameworks und wurde in Java 1.0 eingeführt.
Allerdings gilt die Dictionary-Klasse inzwischen als veraltet und von ihrer Verwendung wird generell abgeraten. Dies liegt daran, dass es vor der Einführung des Collections-Frameworks entwickelt wurde und die Map-Schnittstelle nicht implementiert, was die Verwendung in Verbindung mit anderen Teilen des Frameworks erschwert.
Im Allgemeinen wird empfohlen, die Map-Schnittstelle oder eine ihrer Implementierungen (z. B. HashMap oder ConcurrentHashMap) anstelle der Dictionary-Klasse zu verwenden.
Hier ist ein Beispiel für die Verwendung der Dictionary-Klasse:
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));> >}> >}> }> |
>
>Ausgabe
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Methoden der util.Dictionary-Klasse:
1. put(K-Taste, V-Wert) : java.util.Dictionary.put(K-Taste, V-Wert) Fügt dem Wörterbuch ein Schlüssel-Wert-Paar hinzu.
Syntax :
public abstract V put(K key, V value) Parameters : ->Schlüssel -> Wert Rückgabe: Schlüssel-Wert-Paar, abgebildet im Wörterbuch>
2. elements(): java.util.Dictionary.elements() Gibt die Wertdarstellung im Wörterbuch zurück.
Syntax :
public abstract Enumeration elements() Parameters : -------- Return : value enumeration in dictionary>
3. get(Objektschlüssel) : java.util.Dictionary.get(Objektschlüssel) gibt den Wert zurück, der dem argumentierten Schlüssel im Wörterbuch zugeordnet ist.
Syntax :
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() prüft, ob das Wörterbuch leer ist oder nicht.
Syntax :
public abstract boolean isEmpty() Parameters : ------ Return : true, if there is no key-value relation in the dictionary; else false>
5. Schlüssel(): java.util.Dictionary.keys() gibt die Schlüsseldarstellung im Wörterbuch zurück.
Syntax :
public abstract Enumeration keys() Parameters : -------- Return : key enumeration in dictionary>
6. remove(Object key) : java.util.Dictionary.remove(Object key) Entfernt das mit dem argumentierten Schlüssel zugeordnete Schlüssel-Wert-Paar.
Syntax :
public abstract V remove(Object key) Parameters : key : key to be removed Return : value mapped with the key>
7. size(): java.util.Dictionary.size() gibt die Nr. zurück. von Schlüssel-Wert-Paaren im Wörterbuch.
Syntax :
public abstract int size() Parameters : ------- Return : returns the no. of key-value pairs in the Dictionary>
Java
Array in Java drucken
// 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());> >}> }> |
>
>
Ausgabe:
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>
Vorteile der Dictionary-Klasse:
- Legacy-Unterstützung: Die Dictionary-Klasse war Teil des ursprünglichen Java Collections-Frameworks und war von Anfang an Teil von Java. Das bedeutet, dass Sie älteren Code, der Dictionary verwendet, diesen weiterhin in Ihrem neuen Code verwenden können.
- Einfach zu verwenden: Die Dictionary-Klasse ist einfach zu verwenden und bietet grundlegende Schlüsselwert-Datenstrukturfunktionen, die in einfachen Fällen nützlich sein können.
Nachteile der Dictionary-Klasse:
- Veraltet: Die Dictionary-Klasse gilt als veraltet und von ihrer Verwendung wird generell abgeraten. Dies liegt daran, dass es vor der Einführung des Collections-Frameworks entwickelt wurde und die Map-Schnittstelle nicht implementiert, was die Verwendung in Verbindung mit anderen Teilen des Frameworks erschwert.
- Eingeschränkte Funktionalität: Die Dictionary-Klasse stellt grundlegende Schlüsselwert-Datenstrukturfunktionen bereit, bietet jedoch nicht den gesamten Funktionsumfang, der in der Map-Schnittstelle und ihren Implementierungen verfügbar ist.
- Nicht typsicher: Die Dictionary-Klasse verwendet die Object-Klasse zur Darstellung von Schlüsseln und Werten, was zu Typkonflikten und Laufzeitfehlern führen kann.
Nachschlagewerke:
- Java-Sammlungen von Maurice Naftalin und Philip Wadler. Dieses Buch bietet einen umfassenden Überblick über das Java Collections-Framework, einschließlich der Dictionary-Klasse.
- Java auf den Punkt gebracht von David Flanagan. Dieses Buch bietet eine Kurzreferenz für die Kernfunktionen von Java, einschließlich der Dictionary-Klasse.
- Java Generics and Collections von Maurice Naftalin und Philip Wadler. Dieses Buch bietet eine umfassende Anleitung zu Generika und Sammlungen in Java, einschließlich der Dictionary-Klasse.