Java.util.Dictionary Class in Java

The java.util.Dictionary class in Java is an abstract class that represents a collection of key-value pairs, where keys are unique and are used to access the values. It was part of the Java Collections Framework introduced in Java 1.2 but has been largely replaced by the java.util.Map interface since Java 1.2.

The Dictionary class is an abstract class and cannot be instantiated directly. Instead, it provides the basic operations for accessing the key-value pairs stored in the collection, which are implemented by its concrete subclass java.util.Hashtable.

The Dictionary class defines the following methods:

1. get(Object key): Returns the value associated with the specified key in the dictionary, or null if the key is not found.
2. put(Object key, Object value): Inserts a key-value pair into the dictionary. If the key already exists, its corresponding value is
3. replaced with the new value, and the old value is returned. If the key is new, null is returned.
4. remove(Object key): Removes the key-value pair associated with the specified key from the dictionary, and returns its value. If the key is not found, null is returned.
5. size(): Returns the number of key-value pairs stored in the dictionary.
6. isEmpty(): Returns true if the dictionary is empty, and false otherwise.
   elements(): Returns an enumeration of the values stored in the dictionary.
7. keys(): Returns an enumeration of the keys stored in the dictionary.

Here’s an example of using the Dictionary class:

Java

import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Hashtable;

public class DictionaryExample {
    public static void main(String[] args)
    {
        Dictionary<String, Integer> 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<String> k = dict.keys();
        while (k.hasMoreElements()) {
            String key = k.nextElement();
            System.out.println("Key: " + key + ", Value: "
                               + dict.get(key));
        }
    }
}

Output

30
35
2
Key: Bob, Value: 30
Key: Charlie, Value: 40

util.Dictionary is an abstract class, representing a key-value relation and works similar to a map. Given a key you can store values and when needed can retrieve the value back using its key. Thus, it is a list of key-value pair. 

Declaration

public abstract class Dictionary extends Object

Constructors: 
Dictionary() Sole constructor. 

The java.util.Dictionary class is a class in Java that provides a key-value data structure, similar to the Map interface. It was part of the original Java Collections framework and was introduced in Java 1.0.

However, the Dictionary class has since been considered obsolete and its use is generally discouraged. This is because it was designed prior to the introduction of the Collections framework and does not implement the Map interface, which makes it difficult to use in conjunction with other parts of the framework.

In general, it’s recommended to use the Map interface or one of its implementations (such as HashMap or ConcurrentHashMap) instead of the Dictionary class.

Here’s an example of how to use the Dictionary class:

Java

import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Hashtable;

public class Main {
    public static void main(String[] args) {
        Dictionary<String, Integer> 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<String> keys = dictionary.keys();
        while (keys.hasMoreElements()) {
            String key = keys.nextElement();
            System.out.println("Key: " + key + ", Value: " + dictionary.get(key));
        }
    }
}

Output

Value of A: 1
Key: A, Value: 1
Key: C, Value: 3

Methods of util.Dictionary Class : 

1. put(K key, V value) : java.util.Dictionary.put(K key, V value) adds key-value pair to the dictionary.

Syntax :

public abstract V put(K key, V value)
Parameters : 
-> key
-> value
Return : 
key-value pair mapped in the dictionary

2. elements() : java.util.Dictionary.elements() returns value representation in dictionary.

Syntax :

public abstract Enumeration elements()
Parameters : 
--------
Return : 
value enumeration in dictionary

3. get(Object key) : java.util.Dictionary.get(Object key) returns the value that is mapped with the argumented key in the dictionary.

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() checks whether the dictionary is empty or not. 

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() returns key representation in dictionary.

Syntax :

public abstract Enumeration keys()
Parameters : 
--------
Return : 
key enumeration in dictionary

6. remove(Object key) : java.util.Dictionary.remove(Object key) removes the key-value pair mapped with the argumented key. 

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() returns the no. of key-value pairs in the Dictionary.

Syntax :

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("\nValue at key = 6 : " + geek.get("6"));
        System.out.println("Value at key = 456 : " + geek.get("123"));

        // isEmpty() method :
        System.out.println("\nThere is no key-value pair : " + geek.isEmpty() + "\n");

        // keys() method :
        for (Enumeration k = geek.keys(); k.hasMoreElements();)
        {
            System.out.println("Keys in Dictionary : " + k.nextElement());
        }

        // remove() method :
        System.out.println("\nRemove : " + geek.remove("123"));
        System.out.println("Check the value of removed key : " + geek.get("123"));

        System.out.println("\nSize of Dictionary : " + geek.size());

    }
}

Output:

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

Advantages of Dictionary class:

1. Legacy Support: The Dictionary class was part of the original Java Collections framework and has been part of Java since the beginning. This means that if you have legacy code that uses Dictionary, you can still use it in your new code.
2. Simple to use: The Dictionary class is simple to use and provides basic key-value data structure functionality, which can be useful for simple cases.

Disadvantages of Dictionary class:

1. Obsolete: The Dictionary class is considered obsolete and its use is generally discouraged. This is because it was designed prior to the introduction of the Collections framework and does not implement the Map interface, which makes it difficult to use in conjunction with other parts of the framework.
2. Limited functionality: The Dictionary class provides basic key-value data structure functionality, but does not provide the full range of functionality that is available in the Map interface and its implementations.
3. Not type-safe: The Dictionary class uses the Object class to represent both keys and values, which can lead to type mismatches and runtime errors.

Reference books:

1. “Java Collections” by Maurice Naftalin and Philip Wadler. This book provides a comprehensive overview of the Java Collections framework, including the Dictionary class.
2. “Java in a Nutshell” by David Flanagan. This book provides a quick reference for the core features of Java, including the Dictionary class.
3. “Java Generics and Collections” by Maurice Naftalin and Philip Wadler. This book provides a comprehensive guide to generics and collections in Java, including the Dictionary class.