Klassen java.util.Dictionary i Java är en abstrakt klass som representerar en samling nyckel-värdepar, där nycklar är unika och används för att komma åt värdena. Det var en del av Java Collections Framework som introducerades i Java 1.2 men har till stor del ersatts av gränssnittet java.util.Map sedan Java 1.2.
Ordbok-klassen är en abstrakt klass och kan inte instansieras direkt. Istället tillhandahåller den de grundläggande operationerna för att komma åt nyckel-värdeparen lagrade i samlingen, som implementeras av dess konkreta underklass java.util.Hashtable.
Klassen Dictionary definierar följande metoder:
- get(Objektnyckel): Returnerar värdet som är associerat med den angivna nyckeln i ordboken, eller null om nyckeln inte hittas.
- put(Objektnyckel, Objektvärde): Infogar ett nyckel-värdepar i ordboken. Om nyckeln redan finns är dess motsvarande värde
- ersätts med det nya värdet och det gamla värdet returneras. Om nyckeln är ny returneras null.
- remove(Objektnyckel): Tar bort nyckel-värdeparet som är associerat med den angivna nyckeln från ordboken och returnerar dess värde. Om nyckeln inte hittas returneras null.
- size(): Returnerar antalet nyckel-värdepar lagrade i ordboken.
- isEmpty(): Returnerar sant om ordlistan är tom, och annars falskt.
elements(): Returnerar en uppräkning av värdena lagrade i ordboken. - keys(): Returnerar en uppräkning av nycklar som är lagrade i ordboken.
Här är ett exempel på hur du använder klassen Ordbok:
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));> >}> >}> }> |
>
>Produktion
30 35 2 Key: Bob, Value: 30 Key: Charlie, Value: 40>
util.Ordbok är en abstrakt klass som representerar en nyckelvärde relation och fungerar som en karta. Med en nyckel kan du lagra värden och vid behov kan du hämta värdet tillbaka med hjälp av dess nyckel. Det är alltså en lista över nyckel-värdepar.
Deklaration
public abstract class Dictionary extends Object>
Konstruktörer:
Lexikon() Ensam konstruktör.
Klassen java.util.Dictionary är en klass i Java som tillhandahåller en nyckel-värde datastruktur, liknande Map-gränssnittet. Det var en del av det ursprungliga Java Collections-ramverket och introducerades i Java 1.0.
Ordbok-klassen har dock sedan dess ansetts vara föråldrad och dess användning är generellt avrådig. Detta beror på att det designades innan introduktionen av ramverket Samlingar och inte implementerar kartgränssnittet, vilket gör det svårt att använda i kombination med andra delar av ramverket.
I allmänhet rekommenderas det att använda kartgränssnittet eller en av dess implementeringar (som HashMap eller ConcurrentHashMap) istället för klassen Dictionary.
Här är ett exempel på hur du använder klassen Ordbok:
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));> >}> >}> }> |
>
>Produktion
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Metoder för användning. Ordbok Klass:
1. put(K-nyckel, V-värde): java.util.Dictionary.put(K-nyckel, V-värde) lägger till nyckel-värdepar till ordboken.
Syntax :
public abstract V put(K key, V value) Parameters : ->nyckel -> värde Return : nyckel-värdepar mappas i ordboken>
2. elements(): java.util.Dictionary.elements() returnerar värderepresentation i ordbok.
Syntax :
public abstract Enumeration elements() Parameters : -------- Return : value enumeration in dictionary>
3. get(Objektnyckel): java.util.Dictionary.get(Objektnyckel) returnerar värdet som mappas med den argumenterade nyckeln i ordboken.
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() kontrollerar om ordlistan är tom eller inte.
Syntax :
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() returnerar nyckelrepresentation i ordbok.
Syntax :
public abstract Enumeration keys() Parameters : -------- Return : key enumeration in dictionary>
6. remove(Object key): java.util.Dictionary.remove(Object key) tar bort nyckel-värdeparet mappat med den argumenterade nyckeln.
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() returnerar nr. nyckel-värdepar i ordboken.
Syntax :
public abstract int size() Parameters : ------- Return : returns the no. of key-value pairs in the Dictionary>
Java
skillnad mellan två strängar python
// 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());> >}> }> |
>
>
Produktion:
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>
Fördelar med ordboksklass:
- Legacy Support: Ordbok-klassen var en del av det ursprungliga Java Collections-ramverket och har varit en del av Java sedan starten. Det betyder att om du har äldre kod som använder Dictionary, kan du fortfarande använda den i din nya kod.
- Enkel att använda: Ordbok-klassen är enkel att använda och tillhandahåller grundläggande nyckel-värde datastrukturfunktioner, vilket kan vara användbart för enkla fall.
Nackdelar med ordboksklass:
- Föråldrad: Ordbok-klassen anses vara föråldrad och dess användning avråds i allmänhet. Detta beror på att det designades innan introduktionen av ramverket Samlingar och inte implementerar kartgränssnittet, vilket gör det svårt att använda i kombination med andra delar av ramverket.
- Begränsad funktionalitet: Ordbokklassen tillhandahåller grundläggande nyckel-värde datastrukturfunktioner, men tillhandahåller inte hela utbudet av funktionalitet som är tillgängligt i kartgränssnittet och dess implementeringar.
- Inte typsäker: Klassen Dictionary använder klassen Object för att representera både nycklar och värden, vilket kan leda till typfel och körtidsfel.
Uppslagsverk:
- Java-samlingar av Maurice Naftalin och Philip Wadler. Den här boken ger en omfattande översikt över Java Collections-ramverket, inklusive klassen Dictionary.
- Java i ett nötskal av David Flanagan. Den här boken ger en snabbreferens för Javas kärnfunktioner, inklusive klassen Ordbok.
- Java Generics and Collections av Maurice Naftalin och Philip Wadler. Den här boken ger en omfattande guide till generika och samlingar i Java, inklusive klassen Ordbok.