Java.util.Dictionary Class i Java
Java.util.Dictionary-klassen i Java er en abstrakt klasse, der repræsenterer en samling af nøgle-værdi-par, hvor nøgler er unikke og bruges til at få adgang til værdierne. Det var en del af Java Collections Framework introduceret i Java 1.2, men er stort set blevet erstattet af java.util.Map-grænsefladen siden Java 1.2.
Ordbogsklassen er en abstrakt klasse og kan ikke instansieres direkte. I stedet giver den de grundlæggende operationer for at få adgang til nøgleværdi-parrene, der er gemt i samlingen, som er implementeret af dens konkrete underklasse java.util.Hashtable.
Ordbogsklassen definerer følgende metoder:
- get(Objektnøgle): Returnerer den værdi, der er knyttet til den angivne nøgle i ordbogen, eller nul, hvis nøglen ikke findes.
- put(Objektnøgle, Objektværdi): Indsætter et nøgle-værdi-par i ordbogen. Hvis nøglen allerede findes, er dens tilsvarende værdi
- erstattet med den nye værdi, og den gamle værdi returneres. Hvis nøglen er ny, returneres null.
- remove(Objektnøgle): Fjerner nøgle-værdi-parret forbundet med den angivne nøgle fra ordbogen og returnerer dets værdi. Hvis nøglen ikke findes, returneres null.
- size(): Returnerer antallet af nøgleværdi-par gemt i ordbogen.
- isEmpty(): Returnerer sand, hvis ordbogen er tom, og ellers falsk.
elements(): Returnerer en opregning af de værdier, der er gemt i ordbogen. - keys(): Returnerer en opregning af de nøgler, der er gemt i ordbogen.
Her er et eksempel på brug af klassen Ordbog:
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.ordbog er en abstrakt klasse, der repræsenterer en nøgleværdi relation og arbejder, der ligner et kort. Med en nøgle kan du gemme værdier og efter behov kan du hente værdien tilbage ved hjælp af dens nøgle. Det er således en liste over nøgleværdi-par.
Erklæring
public abstract class Dictionary extends Object
Konstruktører:
Ordbog() Ene konstruktør.
Klassen java.util.Dictionary er en klasse i Java, der giver en nøgleværdi-datastruktur, der ligner Map-grænsefladen. Det var en del af den originale Java Collections-ramme og blev introduceret i Java 1.0.
Ordbogsklassen er dog siden blevet betragtet som forældet, og brugen af den frarådes generelt. Dette skyldes, at det er designet før introduktionen af samlingsrammeværket og ikke implementerer kortgrænsefladen, hvilket gør det vanskeligt at bruge i forbindelse med andre dele af rammeværket.
Generelt anbefales det at bruge kortgrænsefladen eller en af dens implementeringer (såsom HashMap eller ConcurrentHashMap) i stedet for klassen Ordbog.
Her er et eksempel på, hvordan du bruger Ordbogsklassen:
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 til brug. Ordbog Klasse:
1. put(K-tast, V-værdi): java.util.Dictionary.put(K-tast, V-værdi) tilføjer nøgleværdi-par til ordbogen.
Syntaks:
public abstract V put(K key, V value) Parameters : ->nøgle -> værdi Retur: nøgle-værdi-par kortlagt i ordbogen
2. elements(): java.util.Dictionary.elements() returnerer værdirepræsentation i ordbog.
Syntaks:
public abstract Enumeration elements() Parameters : -------- Return : value enumeration in dictionary
3. get(Objektnøgle): java.util.Dictionary.get(Objektnøgle) returnerer den værdi, der er afbildet med den argumenterede nøgle i ordbogen.
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() kontrollerer om ordbogen er tom eller ej.
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øglerepræsentation i ordbog.
Syntaks:
public abstract Enumeration keys() Parameters : -------- Return : key enumeration in dictionary
6. remove(Object key): java.util.Dictionary.remove(Object key) fjerner nøgle-værdi-parret, der er afbildet med den argumenterede nøgle.
Syntaks:
public abstract V remove(Object key) Parameters : key : key to be removed Return : value mapped with the key
7. size(): java.util.Dictionary.size() returnerer nr. af nøgleværdi-par i ordbogen.
Syntaks:
public abstract int size() Parameters : ------- Return : returns the no. of key-value pairs in the Dictionary
Java
// 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
Fordele ved Ordbogsklassen:
- Legacy Support: Ordbogsklassen var en del af den originale Java Collections-ramme og har været en del af Java siden begyndelsen. Det betyder, at hvis du har en ældre kode, der bruger Ordbog, kan du stadig bruge den i din nye kode.
- Enkel at bruge: Ordbogsklassen er enkel at bruge og giver grundlæggende nøgleværdi datastrukturfunktionalitet, som kan være nyttig til simple tilfælde.
Ulemper ved ordbogsklassen:
- Forældet: Ordbogsklassen anses for at være forældet, og brugen af den frarådes generelt. Dette skyldes, at det er designet før introduktionen af samlingsrammeværket og ikke implementerer kortgrænsefladen, hvilket gør det vanskeligt at bruge i forbindelse med andre dele af rammeværket.
- Begrænset funktionalitet: Ordbogsklassen giver grundlæggende nøgleværdidatastrukturfunktionalitet, men giver ikke hele rækken af funktionalitet, der er tilgængelig i kortgrænsefladen og dens implementeringer.
- Ikke typesikker: Ordbogsklassen bruger Object-klassen til at repræsentere både nøgler og værdier, hvilket kan føre til typeuoverensstemmelser og runtime-fejl.
Opslagsbøger:
- Java-samlinger af Maurice Naftalin og Philip Wadler. Denne bog giver et omfattende overblik over Java Collections-rammerne, inklusive Ordbogsklassen.
- Java i en nøddeskal af David Flanagan. Denne bog giver en hurtig reference til kernefunktionerne i Java, inklusive Ordbogsklassen.
- Java Generics and Collections af Maurice Naftalin og Philip Wadler. Denne bog giver en omfattende guide til generiske artikler og samlinger i Java, inklusive Ordbogsklassen.
