De klasse java.util.Dictionary in Java is een abstracte klasse die een verzameling sleutel-waardeparen vertegenwoordigt, waarbij sleutels uniek zijn en worden gebruikt om toegang te krijgen tot de waarden. Het maakte deel uit van het Java Collections Framework dat in Java 1.2 werd geïntroduceerd, maar is sinds Java 1.2 grotendeels vervangen door de java.util.Map-interface.
De klasse Dictionary is een abstracte klasse en kan niet rechtstreeks worden geïnstantieerd. In plaats daarvan biedt het de basisbewerkingen voor toegang tot de sleutel-waardeparen die zijn opgeslagen in de verzameling, die worden geïmplementeerd door de concrete subklasse java.util.Hashtable.
De klasse Dictionary definieert de volgende methoden:
- get(Objectsleutel): Retourneert de waarde die is gekoppeld aan de opgegeven sleutel in het woordenboek, of null als de sleutel niet wordt gevonden.
- put(Objectsleutel, Objectwaarde): Voegt een sleutel-waardepaar in het woordenboek in. Als de sleutel al bestaat, is de bijbehorende waarde
- vervangen door de nieuwe waarde en de oude waarde wordt geretourneerd. Als de sleutel nieuw is, wordt null geretourneerd.
- remove(Object key): Verwijdert het sleutel-waardepaar dat is gekoppeld aan de opgegeven sleutel uit het woordenboek en retourneert de waarde ervan. Als de sleutel niet wordt gevonden, wordt null geretourneerd.
- size(): Retourneert het aantal sleutelwaardeparen dat in het woordenboek is opgeslagen.
- isEmpty(): Retourneert true als het woordenboek leeg is, en false anders.
elements(): Retourneert een opsomming van de waarden die zijn opgeslagen in het woordenboek. - sleutels(): Retourneert een opsomming van de sleutels die zijn opgeslagen in het woordenboek.
Hier is een voorbeeld van het gebruik van de klasse 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));> >}> >}> }> |
>
>Uitvoer
30 35 2 Key: Bob, Value: 30 Key: Charlie, Value: 40>
util.Woordenboek is een abstracte klasse, die a vertegenwoordigt sleutel waarde relatie en werkt vergelijkbaar met een kaart. Met een sleutel kunt u waarden opslaan en indien nodig de waarde terughalen met behulp van de sleutel. Het is dus een lijst met sleutel-waardeparen.
Verklaring
public abstract class Dictionary extends Object>
Constructeurs:
Woordenboek() Enige constructeur.
De klasse java.util.Dictionary is een klasse in Java die een sleutel-waardegegevensstructuur biedt, vergelijkbaar met de Map-interface. Het maakte deel uit van het oorspronkelijke Java Collections-framework en werd geïntroduceerd in Java 1.0.
De klasse Dictionary wordt sindsdien echter als verouderd beschouwd en het gebruik ervan wordt over het algemeen afgeraden. Dit komt omdat het is ontworpen vóór de introductie van het Collections-framework en de Map-interface niet implementeert, waardoor het moeilijk te gebruiken is in combinatie met andere delen van het framework.
Over het algemeen wordt aanbevolen om de Map-interface of een van de implementaties ervan (zoals HashMap of ConcurrentHashMap) te gebruiken in plaats van de Dictionary-klasse.
Hier is een voorbeeld van hoe u de klasse Dictionary gebruikt:
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));> >}> >}> }> |
>
>Uitvoer
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Gebruiksmethoden. Woordenboekklasse:
1. put(K-sleutel, V-waarde): java.util.Dictionary.put(K-sleutel, V-waarde) voegt een sleutelwaardepaar toe aan het woordenboek.
Syntaxis:
public abstract V put(K key, V value) Parameters : ->sleutel -> waarde Return: sleutel-waarde-paar toegewezen in het woordenboek>
2. elementen() : java.util.Dictionary.elements() retourneert waardeweergave in woordenboek.
Syntaxis:
public abstract Enumeration elements() Parameters : -------- Return : value enumeration in dictionary>
3. get(Objectsleutel): java.util.Dictionary.get(Objectsleutel) retourneert de waarde die is toegewezen aan de argumenterende sleutel in het woordenboek.
Syntaxis:
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() controleert of het woordenboek leeg is of niet.
Syntaxis:
public abstract boolean isEmpty() Parameters : ------ Return : true, if there is no key-value relation in the dictionary; else false>
5. sleutels() : java.util.Dictionary.keys() retourneert sleutelrepresentatie in woordenboek.
Syntaxis:
public abstract Enumeration keys() Parameters : -------- Return : key enumeration in dictionary>
6. remove(Objectsleutel): java.util.Dictionary.remove(Objectsleutel) verwijdert het sleutelwaardepaar dat is toegewezen aan de argumenterende sleutel.
Syntaxis:
public abstract V remove(Object key) Parameters : key : key to be removed Return : value mapped with the key>
7. size() : java.util.Dictionary.size() geeft het nr. terug. van sleutel-waardeparen in het woordenboek.
Syntaxis:
public abstract int size() Parameters : ------- Return : returns the no. of key-value pairs in the Dictionary>
Java
Python genereert uuid
// 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());> >}> }> |
>
>
Uitgang:
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>
Voordelen van de Woordenboekles:
- Ondersteuning voor oudere versies: de klasse Dictionary maakte deel uit van het oorspronkelijke Java Collections-framework en maakt sinds het begin deel uit van Java. Dit betekent dat als u een verouderde code heeft die gebruikmaakt van Woordenboek, u deze nog steeds in uw nieuwe code kunt gebruiken.
- Eenvoudig te gebruiken: de klasse Dictionary is eenvoudig te gebruiken en biedt basisfunctionaliteit voor de sleutel-waardegegevensstructuur, wat handig kan zijn voor eenvoudige gevallen.
Nadelen van de klasse Woordenboek:
- Verouderd: de klasse Dictionary wordt als verouderd beschouwd en het gebruik ervan wordt over het algemeen afgeraden. Dit komt omdat het is ontworpen vóór de introductie van het Collections-framework en de Map-interface niet implementeert, waardoor het moeilijk te gebruiken is in combinatie met andere delen van het framework.
- Beperkte functionaliteit: De klasse Dictionary biedt basisfunctionaliteit voor de sleutel-waardedatastructuur, maar biedt niet het volledige scala aan functionaliteit dat beschikbaar is in de Map-interface en de implementaties ervan.
- Niet typeveilig: de klasse Dictionary gebruikt de klasse Object om zowel sleutels als waarden weer te geven, wat kan leiden tot type-mismatches en runtime-fouten.
Naslagwerken:
- Java-collecties van Maurice Naftalin en Philip Wadler. Dit boek biedt een uitgebreid overzicht van het Java Collections-framework, inclusief de klasse Dictionary.
- Java in een notendop door David Flanagan. Dit boek biedt een snel naslagwerk voor de kernfuncties van Java, inclusief de klasse Dictionary.
- Java-generieken en collecties door Maurice Naftalin en Philip Wadler. Dit boek biedt een uitgebreide handleiding voor generieke geneesmiddelen en verzamelingen in Java, inclusief de klasse Dictionary.