Open In App

Differences between TreeMap, HashMap and LinkedHashMap in Java

Prerequisite : HashMap and TreeMap in Java
 

TreeMap, HashMap and LinkedHashMap: What’s Similar?
 

Key Points
 

  1. HashMap: HashMap offers 0(1) lookup and insertion. If you iterate through the keys, though, the ordering of the keys is essentially arbitrary. It is implemented by an array of linked lists. 
    Syntax: 
     
public class HashMap extends AbstractMap 
implements Map,Cloneable, Serializable

 

2. LinkedHashMap: LinkedHashMap offers 0(1) lookup and insertion. Keys are ordered by their insertion order. It is implemented by doubly-linked buckets. 
Syntax: 
 

public class LinkedHashMap extends HashMap 
implements Map

 

3.TreeMap: TreeMap offers O(log N) lookup and insertion. Keys are ordered, so if you need to iterate through the keys in sorted order, you can. This means that keys must implement the Comparable interface. TreeMap is implemented by a Red-Black Tree
Syntax: 
 

public class TreeMap extends AbstractMap implements
NavigableMap, Cloneable, Serializable

 

4. Hashtable: Hashtable” is the generic name for hash-based maps. 
Syntax: 

public class Hashtable extends Dictionary implements
Map, Cloneable, Serializable

 

 




// Java program to print ordering
// of all elements using HashMap
import java.util.*;
import java.lang.*;
import java.io.*;
class Main
{
    // This function prints ordering of all elements
    static void insertAndPrint(AbstractMap<Integer, String> map)
    {
        int[] array= {1, -1, 0, 2,-2};
        for (int x: array)
        {
            map.put(x, Integer.toString(x));
        }
        for (int k: map.keySet())
        {
            System.out.print(k + ", ");
        }
    }
 
    // Driver method to test above method
    public static void main (String[] args)
    {
        HashMap<Integer, String> map = new HashMap<Integer, String>();
        insertAndPrint(map);
    }
}




// Java program to print ordering
// of all elements using LinkedHashMap
import java.util.*;
import java.lang.*;
import java.io.*;
 
class Main
{
    // This function prints ordering of all elements
    static void insertAndPrint(AbstractMap<Integer, String> map)
    {
        int[] array= {1, -1, 0, 2,-2};
        for (int x: array)
        {
            map.put(x, Integer.toString(x));
        }
        for (int k: map.keySet())
        {
            System.out.print(k + ", ");
        }
    }
     
    // Driver method to test above method
    public static void main (String[] args)
    {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<Integer, String>();
        insertAndPrint(map);
    }
}




// Java program to print ordering of
// all elements using TreeMap
 
import java.util.*;
import java.lang.*;
import java.io.*;
 
class Main
{
    // This function prints ordering of all elements
    static void insertAndPrint(AbstractMap<Integer, String> map)
    {
        int[] array= {1, -1, 0, 2,-2};
        for (int x: array)
        {
            map.put(x, Integer.toString(x));
        }
        for (int k: map.keySet())
        {
            System.out.print(k + ", ");
        }
    }
 
    // Driver method to test above method
    public static void main (String[] args)
    {
        TreeMap<Integer, String> map = new TreeMap<Integer, String>();
        insertAndPrint(map);
    }
}

Output of HashMap: 
 

-1, 0, 1, -2, 2,     
// ordering of the keys is essentially arbitrary (any ordering)

Output of LinkedHashMap: 
 

 1, -1, 0, 2, -2,     
// Keys are ordered by their insertion order

Output of TreeMap: 
 

 -2, -1, 0, 1, 2,   
// Keys are in sorted order

Comparison Table
 

 

Real Life Applications

  1. Suppose you were creating a mapping of names to Person objects. You might want to periodically output the people in alphabetical order by name. A TreeMap lets you do this.
  2. A TreeMap also offers a way to, given a name, output the next 10 people. This could be useful for a “More”function in many applications.
  3. A LinkedHashMap is useful whenever you need the ordering of keys to match the ordering of insertion. This might be useful in a caching situation, when you want to delete the oldest item.
  4. Generally, unless there is a reason not to, you would use HashMap. That is, if you need to get the keys back in insertion order, then use LinkedHashMap. If you need to get the keys back in their true/natural order, then use TreeMap. Otherwise, HashMap is probably best. It is typically faster and requires less overhead.

This article is contributed by Mr. Somesh Awasthi.

 


Article Tags :