Difference Between a HashMap and a Dictionary in Java
Last updated: December 17, 2024
Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.
Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.
In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:
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!
