Java Java.util.Dictionary用法及代码示例

Java中的java.util.Dictionary类是一个抽象类，它表示键值对的集合，其中键是唯一的，用于访问值。它是 Java 1.2 中引入的 Java 集合框架的一部分，但自 Java 1.2 以来已被 java.util.Map 接口所取代。

Dictionary 类是一个抽象类，不能直接实例化。相反，它提供了访问存储在集合中的键值对的基本操作，这些操作由其具体子类 java.util.Hashtable 实现。

Dictionary 类定义了以下方法：

1. get(Object key)：返回与字典中指定键关联的值，如果未找到该键则返回 null。
2. put(Object key, Object value)：将键值对插入字典中。如果key已经存在，则对应的值为
3. 替换为新值，并返回旧值。如果 key 是新的，则返回 null。
4. remove(Object key)：从字典中删除与指定键关联的键值对，并返回其值。如果未找到该键，则返回 null。
5. size()：返回字典中存储的键值对的数量。
6. isEmpty()：如果字典为空，则返回 true，否则返回 false。
   elements()：返回存储在字典中的值的枚举。
7. keys()：返回存储在字典中的键的枚举。

这是使用 Dictionary 类的示例：

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));
        }
    }
}

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

util.Dictionary 是一个抽象类，表示键值关系，其工作方式类似于映射。给定一个键，您可以存储值，并在需要时可以使用其键检索值。因此，它是一个键值对的列表。

声明

public abstract class Dictionary extends Object

构造函数：
Dictionary()唯一的构造函数。

java.util.Dictionary类是Java中提供键值数据结构的类，类似于Map接口。它是原始 Java Collections 框架的一部分，在 Java 1.0 中引入。

然而，Dictionary 类已被认为已过时，并且通常不鼓励使用它。这是因为它是在Collections框架引入之前设计的，没有实现Map接口，这使得它很难与框架的其他部分结合使用。

一般来说，建议使用 Map 接口或其实现之一(例如HashMap 或 ConcurrentHashMap)而不是 Dictionary 类。

以下是如何使用 Dictionary 类的示例：

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));
        }
    }
}

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

util.Dictionary 类的方法：

1. put(K键,V值): java.util.Dictionary.put(K键,V值)将键值对添加到字典中。

用法:

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()返回字典中的值表示。

用法:

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

3. get(Object key)：java.util.Dictionary.get(Object key) 返回与字典中的参数键映射的值。

用法:

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()检查字典是否为空。

用法:

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()返回字典中的键表示。

用法:

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

6. 删除(对象键): java.util.Dictionary.remove(对象键)删除与参数键映射的键值对。

用法:

public abstract V remove(Object key)
Parameters : 
key : key to be removed
Return : 
value mapped with the key

7. size(): java.util.Dictionary.size() 返回编号。字典中的键值对。

用法:

public abstract int size()
Parameters : 
-------
Return : 
returns the no. of key-value pairs in the Dictionary

// 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());
    }
}

输出：

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

Dictionary类的优点：

1. 遗留支持：Dictionary 类是原始 Java Collections 框架的一部分，并且从一开始就是 Java 的一部分。这意味着，如果您有使用 Dictionary 的旧代码，您仍然可以在新代码中使用它。
2. 使用简单：Dictionary 类使用简单，并提供基本的键值数据结构函数，这对于简单的情况很有用。

Dictionary类的缺点：

1. 已过时：Dictionary 类被认为已过时，并且通常不鼓励使用它。这是因为它是在Collections框架引入之前设计的，没有实现Map接口，这使得它很难与框架的其他部分结合使用。
2. 函数有限：Dictionary 类提供基本的键值数据结构函数，但不提供 Map 接口及其实现中可用的全部函数。
3. 不类型安全：Dictionary 类使用 Object 类来表示键和值，这可能会导致类型不匹配和运行时错误。

相关书籍：

1. “Java Collections” 作者：莫里斯·纳夫塔林和菲利普·瓦德勒。本书全面概述了 Java Collections 框架，包括 Dictionary 类。
2. David Flanagan 的《Java 简介》。本书提供了 Java 核心函数(包括 Dictionary 类)的快速参考。
3. Maurice Naftalin 和 Philip Wadler 的“Java 泛型和集合”。本书提供了 Java 中泛型和集合的全面指南，包括 Dictionary 类。