Difference between HashMap and LinkedHashMap in Java

Hey everyone, welcome back to the blog post! Today, we’re comparing two important implementations of the Map interface in Java—HashMap and LinkedHashMap. While they share many similarities, there are a few key differences when it comes to ordering and performance. Let’s dive into the details and see some examples to understand when you should use each.

Difference between HashMap and LinkedHashMap in Java

1. Difference 1: Internal Data Structure

First, let’s talk about the internal structure. HashMap uses a hash table to store its key-value pairs, which allows for fast lookups and retrieval of data. However, the order of the elements is not guaranteed. In contrast, LinkedHashMap extends HashMap and adds a doubly linked list to maintain the insertion order of the entries. This means that the order in which elements are added is preserved during iteration.

Example:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class MapComparison {
    public static void main(String[] args) {
        // HashMap example
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put("B", "Banana");
        hashMap.put("A", "Apple");
        hashMap.put("C", "Cherry");
        System.out.println("HashMap Output: " + hashMap);

        // LinkedHashMap example
        Map<String, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("B", "Banana");
        linkedHashMap.put("A", "Apple");
        linkedHashMap.put("C", "Cherry");
        System.out.println("LinkedHashMap Output: " + linkedHashMap);
    }
}

Output:

HashMap Output: {A=Apple, B=Banana, C=Cherry} or {B=Banana, C=Cherry, A=Apple} (order is unpredictable)
LinkedHashMap Output: {B=Banana, A=Apple, C=Cherry} (insertion order preserved)

2. Difference 2: Order of Elements

As we just saw, one of the major differences between HashMap and LinkedHashMap is the order of elements. HashMap does not maintain any particular order of its entries, so when you iterate through it, the order may seem random. However, LinkedHashMap maintains the order in which you added elements, making it useful when the order of elements matters.

Example:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class MapOrderComparison {
    public static void main(String[] args) {
        // HashMap example
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("One", 1);
        hashMap.put("Three", 3);
        hashMap.put("Two", 2);
        System.out.println("HashMap Output: " + hashMap); // No guaranteed order

        // LinkedHashMap example
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("One", 1);
        linkedHashMap.put("Three", 3);
        linkedHashMap.put("Two", 2);
        System.out.println("LinkedHashMap Output: " + linkedHashMap); // Maintains insertion order
    }
}

Output:

HashMap Output: {One=1, Three=3, Two=2} or any random order
LinkedHashMap Output: {One=1, Three=3, Two=2} (insertion order preserved)

3. Difference 3: Performance

In terms of performance, HashMap is slightly faster than LinkedHashMap because it doesn’t need to maintain the insertion order. Most operations, like adding, removing, and looking up elements, take constant time, O(1). LinkedHashMap performs similarly for these operations but has a slight overhead due to the linked list that maintains the order.

Example:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class MapPerformanceComparison {
    public static void main(String[] args) {
        // HashMap performance
        Map<Integer, String> hashMap = new HashMap<>();
        long startTime = System.nanoTime();
        hashMap.put(1, "Apple");
        hashMap.put(2, "Banana");
        hashMap.put(3, "Cherry");
        System.out.println("HashMap contains key 2: " + hashMap.containsKey(2));
        long endTime = System.nanoTime();
        System.out.println("HashMap operation time: " + (endTime - startTime) + " ns");

        // LinkedHashMap performance
        Map<Integer, String> linkedHashMap = new LinkedHashMap<>();
        startTime = System.nanoTime();
        linkedHashMap.put(1, "Apple");
        linkedHashMap.put(2, "Banana");
        linkedHashMap.put(3, "Cherry");
        System.out.println("LinkedHashMap contains key 2: " + linkedHashMap.containsKey(2));
        endTime = System.nanoTime();
        System.out.println("LinkedHashMap operation time: " + (endTime - startTime) + " ns");
    }
}

Output:

HashMap contains key 2: true
HashMap operation time: [Shorter time in nanoseconds]

LinkedHashMap contains key 2: true
LinkedHashMap operation time: [Slightly longer time in nanoseconds due to maintaining order]

4. Difference 4: Null Keys and Values

Both HashMap and LinkedHashMap allow null keys and values. You can insert one null key and multiple null values in either implementation. However, keep in mind that the null key will still be subject to hashing.

Example:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class NullComparison {
    public static void main(String[] args) {
        // HashMap example - allows null key and values
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put(null, "Banana");
        hashMap.put("Apple", null);
        System.out.println("HashMap with nulls: " + hashMap);

        // LinkedHashMap example - allows null key and values
        Map<String, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put(null, "Banana");
        linkedHashMap.put("Apple", null);
        System.out.println("LinkedHashMap with nulls: " + linkedHashMap);
    }
}

Output:

HashMap with nulls: {null=Banana, Apple=null}
LinkedHashMap with nulls: {null=Banana, Apple=null} (same as HashMap)

Conclusion

That’s a wrap on today’s comparison between HashMap and LinkedHashMap! To summarize: HashMap is faster and is useful when you don’t care about the order of elements, while LinkedHashMap is ideal when you need to maintain insertion order with only a slight performance overhead. Try running these examples in your IDE to see how they work in different scenarios

Summary Table: HashMap vs LinkedHashMap

This script provides a clear and informative comparison between HashMap and LinkedHashMap, with examples that can be easily copied and run in an IDE. Let me know if you need any more changes!