Difference Between a HashMap and a Dictionary in Java

1. Overview

Java developers often encounter HashMap and Dictionary when working with key-value pair data structures. At first glance, they might seem interchangeable, but they have significant differences in design, performance, and compatibility with modern Java practices.

In this tutorial, we’ll explore these differences in depth and clearly explain when and why to use each.

2. Introduction

Let’s start with a brief introduction to HashMap and Dictionary.

2.1. HashMap

HashMap was introduced in Java 2. Part of the Java Collections Framework (JCF), it’s a highly efficient and flexible implementation for storing key-value pairs. HashMap supports null keys and values, making it versatile for modern applications. We’ll learn more about this in further sections.

2.2. Dictionary

A relic from Java 1.0, Dictionary is an abstract class for key-value pair storage. While it provided a foundation for early Java programs, it’s now considered obsolete and rarely used outside legacy systems. It doesn’t integrate with the Collections Framework and lacks modern features like generics.

3. Null Handling

One of the most noticeable differences is how they handle null values. Developers usually encounter NullPointerException, so it’s important to handle it using some concepts in Java. So, let’s see how HashMap and Dictionary play their role in handling NullPointerException.

3.1. HashMap

We can have one null key and multiple null values in HashMap. This feature suits it for situations where absent or undefined values need representation.

Let’s see how:

HashMap<String, String> map = new HashMap<>();
map.put(null, "NullKeyValue");
map.put("Key1", null);

3.2. Dictionary

Null keys and null values are not allowed in Dictionary, as most implementations (like Hashtable) throw a NullPointerException when we attempt to insert them.

Let’s see how:

Dictionary<String, String> dictionary = new Hashtable<>();
dictionary.put(null, "NullKey");

Here, is the code dictionary.put(null, “NullKey”) will throw a NullPointerException, so we shouldn’t use a Dictionary where we are likely to encounter null keys or values.

4. Thread Safety

Thread safety is another important concept when dealing with multithreading. In this section, let’s explore how HashMap and Dictionary behave.

4.1. HashMap

HashMap is not synchronized by default, making it faster in single-threaded scenarios. If we need thread safety, the first way we can wrap it is using Collections.synchronizedMap():

Map<String, String> synchronizedMap = Collections.synchronizedMap(new HashMap<>());

The other way is using ConcurrentHashMap, which offers a thread-safe alternative with better performance in concurrent environments.

4.2. Dictionary

Dictionary is synchronized by default, but this comes with a performance cost. For modern multi-threaded applications, ConcurrentHashMap is a better choice.

5. Generic Support

5.1. HashMap

HashMap fully supports generics, which makes it type-safe and eliminates the need for explicit casting. This feature reduces runtime errors and improves code readability.

Let’s see how to use HashMap with generics:

Map<Integer, String> map = new HashMap<>();
map.put(1, "One");
String value = map.get(1);

No casting is required to get value for HashMap.

5.2. Dictionary

Dictionary lacks generics as it predates their introduction in Java 5. Every time we retrieve a value, we must explicitly cast it, thus increasing the likelihood of runtime errors.

Let’s see an example:

Dictionary dictionary = new Hashtable();
dictionary.put(1, "One");
String value = (String) dictionary.get(1);

So, as seen in the above code, we need to explicitly cast the datatype for getting a value from Dictionary.

6. Conclusion

In this article, we saw that, between HashMap and Dictionary, there’s a clear winner for modern Java development: HashMap. It’s faster, more flexible, and offers better features like generics and support for null values.

While Dictionary has its place in Java’s history, it’s best left in the past unless we’re working on old codebases. The next time we need to pick a key-value pair data structure, we know which one to choose!

As always, the code presented in this article is available over on GitHub.