Difference Between Map and HashMap in Java – Java中Map和HashMap的区别

最后修改: 2022年 2月 24日

1. Overview


The difference between Map and HashMap is that the first one is an interface, and the second is an implementation. However, in this article, we’ll dig a bit deeper and explain why interfaces are useful. Also, we’ll learn how to make code more flexible with interfaces and why we have different implementations for the same interface.


2. Purpose of Interfaces


An interface is a contract that defines only behavior. Each class that implements a particular interface should fulfill this contract. To understand it better, we can take an example from real life. Imagine a car. Every person will have a different image in their mind. The term car implies some qualities and behavior. Any object that has these qualities can be called a car. That is why every one of us imagined a different car.


Interfaces work the same. Map is an abstraction that defines certain qualities and behaviors. Only the class that has all of these qualities can be a Map.


3. Different Implementations


We have different implementations of the Map interface for the same reason we have different car models. All the implementations serve different purposes. It’s impossible to find the best implementation overall. There is only the best implementation for some purpose. Although a sports car is fast and looks cool, it is not the best choice for a family picnic or trip to a furniture store.


HashMap is the simplest implementation of the Map interface and provides the basic functionality. Mostly, this implementation covers all the needs. Two other widely used implementations are TreeMap, and LinkedHashMap provides additional features.


Here is a more detailed but not complete hierarchy:


Map hierarchy

4. Programming to Implementations


Imagine that we would like to print the keys and values of a HashMap in the console:


public class HashMapPrinter {

    public void printMap(final HashMap<?, ?> map) {
        for (final Entry<?, ?> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());

This is a small class that does the job. However, it contains one problem. It will be able to work only with the HashMap. Therefore any attempt to pass into the method TreeMap or even HashMap, referenced by Map will result in a compile error:


public class Main {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        HashMap<String, String> hashMap = new HashMap<>();
        TreeMap<String, String> treeMap = new TreeMap<>();

        HashMapPrinter hashMapPrinter = new HashMapPrinter();
//        hashMapPrinter.printMap(treeMap); Compile time error
//        hashMapPrinter.printMap(map); Compile time error

Let’s try to understand why it’s happening. In both of these cases, the compiler cannot be sure that inside this method, there won’t be any invocations on HashMap specific methods.


TreeMap is on a different branch of the Map implementation (no pun intended), thus it might lack some methods that are defined in the HashMap


In the second case, despite the real underlying object of a type HashMap, it is referenced by the Map interface. Therefore, this object will be able to expose only methods defined in the Map and not in the HashMap.


Thus, even though our HashMapPrinter is quite a simple class, it’s too specific. With this approach, it would require us to create a specific Printer for each Map implementation.


5. Programming to Interfaces


Often beginners get confused about the meaning of the expression “program to interfaces” or “code against interfaces”. Let’s consider the following example, which will make it a bit clearer. We’ll change the type of the argument to the most general type possible, which is the Map:

初学者往往对 “对接口编程 “或 “对接口编码 “的含义感到困惑。让我们考虑一下下面的例子,这将使它变得更清楚一些。我们将把参数的类型改为最一般的类型,也就是Map:

public class MapPrinter {
    public void printMap(final Map<?, ?> map) {
        for (final Entry<?, ?> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());

As we can see, the actual implementation stayed the same, while the only change is the type of argument. This shows that the method didn’t use any specific methods of HashMap. All the needed functionality was already defined in the Map interface, namely, method entrySet().


As a result, this minor change created a huge difference. Now, this class can work with any Map implementation:


public class Main {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        HashMap<String, String> hashMap = new HashMap<>();
        TreeMap<String, String> treeMap = new TreeMap<>();

        MapPrinter mapPrinter = new MapPrinter();

Coding to interface helped us to create a versatile class that can work with any implementation of the Map interface. This approach can eliminate code duplication and ensure our classes and methods have a well-defined purpose.

按照接口编码帮助我们创建了一个多功能的类,可以与Map 接口的任何实现一起工作。这种方法可以消除代码的重复,并确保我们的类和方法有一个明确的目的。

6. Where to Use Interfaces


Overall, arguments should be of the most general type possible. We saw in a previous example how just a simple change in a signature of a method could improve our code. Another place where we should have the same approach is a constructor:


public class MapReporter {

    private final Map<?, ?> map;

    public MapReporter(final Map<?, ?> map) {
        this.map = map;

    public void printMap() {
        for (final Entry<?, ?> entry : this.map.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());

This class can work with any implementation of the Map, just because we used the right type in the constructor.


7. Conclusion


To summarize, in this tutorial we discussed why interfaces are a great means for abstraction and defining a contract. Using the most general type possible will make code easy to reuse and easy to read. At the same time, this approach reduces the amount of code which is always a good way to simplify the codebase.


As always, the code is available over on GitHub.