Java.util.Dictionary-klassen i Java er en abstrakt klasse som representerer en samling nøkkelverdi-par, der nøkler er unike og brukes for å få tilgang til verdiene. Det var en del av Java Collections Framework introdusert i Java 1.2, men har i stor grad blitt erstattet av java.util.Map-grensesnittet siden Java 1.2.
Ordbok-klassen er en abstrakt klasse og kan ikke instansieres direkte. I stedet gir den de grunnleggende operasjonene for å få tilgang til nøkkelverdi-parene som er lagret i samlingen, som er implementert av dens konkrete underklasse java.util.Hashtable.
Ordbok-klassen definerer følgende metoder:
- get(Objektnøkkel): Returnerer verdien knyttet til den angitte nøkkelen i ordboken, eller null hvis nøkkelen ikke finnes.
- put(Objektnøkkel, Objektverdi): Setter inn et nøkkelverdi-par i ordboken. Hvis nøkkelen allerede eksisterer, er dens tilsvarende verdi
- erstattet med den nye verdien, og den gamle verdien returneres. Hvis nøkkelen er ny, returneres null.
- remove(Objektnøkkel): Fjerner nøkkel-verdi-paret knyttet til den angitte nøkkelen fra ordboken, og returnerer verdien. Hvis nøkkelen ikke blir funnet, returneres null.
- size(): Returnerer antall nøkkelverdi-par som er lagret i ordboken.
- isEmpty(): Returnerer sann hvis ordboken er tom, og ellers usann.
elements(): Returnerer en oppregning av verdiene som er lagret i ordboken. - keys(): Returnerer en oppregning av nøklene som er lagret i ordboken.
Her er et eksempel på bruk av Ordbok-klassen:
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));> >}> >}> }> |
>
>Produksjon
30 35 2 Key: Bob, Value: 30 Key: Charlie, Value: 40>
util.Ordbok er en abstrakt klasse som representerer en nøkkelverdi relasjon og arbeider som ligner på et kart. Gitt en nøkkel kan du lagre verdier og ved behov kan du hente verdien tilbake ved å bruke nøkkelen. Dermed er det en liste over nøkkelverdi-par.
Erklæring
public abstract class Dictionary extends Object>
Konstruktører:
Ordbok() Enekonstruktør.
Java.util.Dictionary-klassen er en klasse i Java som gir en nøkkelverdi-datastruktur, lik Map-grensesnittet. Det var en del av det originale Java Collections-rammeverket og ble introdusert i Java 1.0.
Imidlertid har Ordbok-klassen siden blitt ansett som foreldet, og bruken av den frarådes generelt. Dette er fordi det ble designet før introduksjonen av rammeverket for samlinger og ikke implementerer kartgrensesnittet, noe som gjør det vanskelig å bruke det sammen med andre deler av rammeverket.
Generelt anbefales det å bruke kartgrensesnittet eller en av dets implementeringer (som HashMap eller ConcurrentHashMap) i stedet for Ordbok-klassen.
Her er et eksempel på hvordan du bruker Ordbok-klassen:
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));> >}> >}> }> |
>
>Produksjon
Value of A: 1 Key: A, Value: 1 Key: C, Value: 3>
Metoder for bruk. Ordbok Klasse:
1. put(K-tast, V-verdi): java.util.Dictionary.put(K-tast, V-verdi) legger til nøkkelverdi-par til ordboken.
Syntaks:
public abstract V put(K key, V value) Parameters : ->nøkkel -> verdi Retur: nøkkel-verdi-par kartlagt i ordboken>
2. elements(): java.util.Dictionary.elements() returnerer verdirepresentasjon i ordbok.
Syntaks:
public abstract Enumeration elements() Parameters : -------- Return : value enumeration in dictionary>
3. get(Objektnøkkel): java.util.Dictionary.get(Objektnøkkel) returnerer verdien som er tilordnet med den argumenterte nøkkelen i ordboken.
Syntaks:
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() sjekker om ordboken er tom eller ikke.
Syntaks:
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() returnerer nøkkelrepresentasjon i ordbok.
Syntaks:
public abstract Enumeration keys() Parameters : -------- Return : key enumeration in dictionary>
6. remove(Object key): java.util.Dictionary.remove(Object key) fjerner nøkkel-verdi-paret tilordnet med den argumenterte nøkkelen.
Syntaks:
public abstract V remove(Object key) Parameters : key : key to be removed Return : value mapped with the key>
7. størrelse() : java.util.Dictionary.size() returnerer nr. av nøkkel-verdi-par i ordboken.
Syntaks:
public abstract int size() Parameters : ------- Return : returns the no. of key-value pairs in the Dictionary>
Java
java-inngang
// 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());> >}> }> |
>
>
Produksjon:
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>
Fordeler med ordbokklassen:
- Eldre støtte: Ordbok-klassen var en del av det originale Java Collections-rammeverket og har vært en del av Java siden begynnelsen. Dette betyr at hvis du har eldre kode som bruker Dictionary, kan du fortsatt bruke den i den nye koden.
- Enkel å bruke: Ordbok-klassen er enkel å bruke og gir grunnleggende nøkkelverdi-datastrukturfunksjonalitet, som kan være nyttig for enkle tilfeller.
Ulemper med ordbokklassen:
- Foreldet: Ordbok-klassen anses som foreldet og bruken frarådes generelt. Dette er fordi det ble designet før introduksjonen av rammeverket for samlinger og ikke implementerer kartgrensesnittet, noe som gjør det vanskelig å bruke det sammen med andre deler av rammeverket.
- Begrenset funksjonalitet: Ordbok-klassen gir grunnleggende nøkkelverdi-datastrukturfunksjonalitet, men gir ikke hele spekteret av funksjonalitet som er tilgjengelig i kartgrensesnittet og dets implementeringer.
- Ikke typesikker: Ordbok-klassen bruker Object-klassen til å representere både nøkler og verdier, noe som kan føre til typefeil og kjøretidsfeil.
Referanse bøker:
- Java-samlinger av Maurice Naftalin og Philip Wadler. Denne boken gir en omfattende oversikt over Java Collections-rammeverket, inkludert Ordbok-klassen.
- Java i et nøtteskall av David Flanagan. Denne boken gir en rask referanse for kjernefunksjonene til Java, inkludert Ordbok-klassen.
- Java Generics and Collections av Maurice Naftalin og Philip Wadler. Denne boken gir en omfattende veiledning til generikk og samlinger i Java, inkludert Ordbok-klassen.