TreeMap in Java

Java TreeMap is a class that implements the Map interface. It is a tree-based implementation that can store key-value data in sorted order efficiently. It is similar to HashMap but has a few differences which we will see towards the end of this tutorial.

TreeMap in Java

TreeMap stores values corresponding to its keys where the key should not be null while the values can be null if required. It maintains an ascending sorting order where the data should be unique and cannot contain duplicate values. It sorts in natural order based on the keys in ascending order. We can also sort the data using a comparator. It implements the Map and Navigable interface and extends the Abstract class.

TreeMap is not thread-safe since it is unsynchronized. It is present in the java.util where we need to import the java.util.TreeMap package to use the TreeMap.

TreeMap constructor

The Java TreeMap class uses the below constructors:

Example: TreeMap using map

The below example shows how to instantiate a treemap using Map. We can see that the entries are sorted in the ascending order based on the keys.

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class TreeMapConst {

  public static void main(String[] args) {
    Map<String,String> m = new HashMap<String,String>();
    m.put("red", "Apple");
    m.put("blue", "blueberry");
    m.put("green", "kiwi");

    TreeMap<String,String> tm = new TreeMap<String,String>(m);
    System.out.println(tm);

  }

}

{blue=blueberry, green=kiwi, red=Apple}

Example: TreeMap using SortedMap

The below example shows how to instantiate a treemap using SortedMap.

import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentSkipListMap;

public class TreeMapConst {

  public static void main(String[] args) {
    
    SortedMap<String,String> sm = new ConcurrentSkipListMap<String,String>();
    sm.put("red", "Apple");
    sm.put("blue", "Blueberry");
    sm.put("green", "Kiwi");
    
    TreeMap<String,String> tm = new TreeMap<String,String>(sm);
    System.out.println(tm);
  }

}

{blue=Blueberry, green=Kiwi, red=Apple}

TreeMap Methods

The Java TreeMap supports the below methods.

Example: Add elements to TreeMap

Below is the example that illustrates to add elements to a TreeMap using the put() method. As we saw earlier, the TreeMap displays the entries in the natural sorting order based on the keys.

import java.util.TreeMap;
public class TreeMapDemo {

  public static void main(String[] args) {
    TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
    tm.put(111, "Aditya");
    tm.put(333, "Bharat");
    tm.put(222, "Dev");
    tm.put(555, "Hari");
    tm.put(444, "Charan");
    
    
    System.out.println(tm.toString());
  }

}

{111=Aditya, 222=Dev, 333=Bharat, 444=Charan, 555=Hari}

Example: Retrieve entries from TreeMap

In the below example, we can see how we can retrieve various entries in comparison with the specified key.

import java.util.Map.Entry;
import java.util.TreeMap;

public class RetrieveTreeMapEntries {

  public static void main(String[] args) {
    TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
    tm.put(111, "Aditya");
    tm.put(333, "Bharat");
    tm.put(222, "Dev");
    tm.put(555, "Hari");
    tm.put(444, "Charan");
    Entry<Integer,String> eceiling = tm.ceilingEntry(222);
    System.out.println("Ceiling Entry: " + eceiling.getKey() + " " + eceiling.getValue());
    Entry<Integer,String> efloor = tm.floorEntry(222);
    System.out.println("Floor Entry: " + efloor.getKey() + " " + efloor.getValue());
    Entry<Integer,String> efirst = tm.firstEntry();
    System.out.println("First Entry: " + efirst.getKey() + " " + efirst.getValue());	
    Entry<Integer,String> elast = tm.lastEntry();
    System.out.println("Last Entry: " + elast.getKey() + " " + elast.getValue());	
    Entry<Integer,String> ehigh = tm.higherEntry(222);
    System.out.println("Higher Entry: " + ehigh.getKey() + " " + ehigh.getValue());
    Entry<Integer,String>elower = tm.lowerEntry(222);
    System.out.println("Lower Entry: " + elower.getKey() + " " + elower.getValue());
  }

}

Ceiling Entry: 222 Dev
Floor Entry: 222 Dev
First Entry: 111 Aditya
Last Entry: 555 Hari
Higher Entry: 333 Bharat
Lower Entry: 111 Aditya

Example: Retrieve keys in Java TreeMap

The below example shows you how to retrieve keys from a Java TreeMap in comparison with the specified key.

import java.util.TreeMap;
import java.util.Map.Entry;

public class RetrieveTreeMapKeys {

  public static void main(String[] args) {
    TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
    tm.put(111, "Aditya");
    tm.put(333, "Bharat");
    tm.put(222, "Dev");
    tm.put(555, "Hari");
    tm.put(444, "Charan");
    
    System.out.println("Ceiling Key: " + tm.ceilingKey(222));
    System.out.println("Floor Key: " + tm.floorKey(222));
    System.out.println("First Key: " + tm.firstKey());
    System.out.println("Last Key: " + tm.lastKey());	
    System.out.println("Higher Key: " + tm.higherKey(222));
    System.out.println("Lower Key: " + tm.lowerKey(222));
   
  }

}

Ceiling Key: 222
Floor Key: 222
First Key: 111
Last Key: 555
Higher Key: 333
Lower Key: 111

Example: Remove entries from Java TreeMap

The below example illustrates how to remove entries from TreeMap using the remove() method. We can also remove the first and last entry alone using the pollFirstEntry() and pollLastEntry() methods.

import java.util.TreeMap;

public class RemoveEntriesTreeMap {

  public static void main(String[] args) {
    TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
    tm.put(111, "Aditya");
    tm.put(333, "Bharat");
    tm.put(222, "Dev");
    tm.put(555, "Hari");
    tm.put(444, "Charan");
    
    System.out.println("Poll First Entry: " + tm.pollFirstEntry());
    System.out.println("Poll Last Entry: " + tm.pollLastEntry());
    
    System.out.println("Remove Key 222: " + tm.remove(222));
    System.out.println("Remove Entry 333: " + tm.remove(333, "Bharat"));
    
    System.out.println("Entries in the TreeMap after remove operation: " + tm);

  }

}

Poll First Entry: 111=Aditya
Poll Last Entry: 555=Hari
Remove Key 222: Dev
Remove Entry 333: true
Entries in the TreeMap after remove operation: {444=Charan}

Example: Check and retrieve key-value from Java TreeMap

The below example shows how to check if a treemap contains a given key or value using the containsKey() and containsValue() method. We can get a specific value using the get() or getOrDefault()and get all values using the values() method.

 import java.util.TreeMap;

public class TreeMapContains {

  public static void main(String[] args) {
    TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
    tm.put(111, "Aditya");
    tm.put(333, "Bharat");
    tm.put(222, "Dev");
    tm.put(555, "Hari");
    tm.put(444, "Charan");
    
    System.out.println("Contains key: " + tm.containsKey(333));
    System.out.println("Contains key: " + tm.containsKey(123));
    System.out.println("Contains Value: " + tm.containsValue("Dev"));
    System.out.println("Contains Value: " + tm.containsValue("aaa"));
    System.out.println("Get: " + tm.get(555));
    System.out.println("Get or default: " + tm.getOrDefault(444, "Test"));
    System.out.println("Get or default: " + tm.getOrDefault(123, "Test"));
    System.out.println("Values: " + tm.values());

  }

}

Contains key: true
Contains key: false
Contains Value: true
Contains Value: false
Get: Hari
Get or default: Charan
Get or default: Test
Values: [Aditya, Dev, Bharat, Charan, Hari]

Example: Descending sorting

TreeMap sorts the data by default in the ascending order of keys. But we can sort them in descending order using the descendingKeySet() to sort the keys in reverse order and descendingMap() to sort the key-value pairs in the reverse order.

import java.util.TreeMap;

public class DescendingTreeMap {

  public static void main(String[] args) {
    TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
    tm.put(111, "Aditya");
    tm.put(333, "Bharat");
    tm.put(222, "Dev");
    tm.put(555, "Hari");
    tm.put(444, "Charan");
    
    System.out.println(tm.descendingKeySet());
    System.out.println(tm.descendingMap());

  }

}

[555, 444, 333, 222, 111]
{555=Hari, 444=Charan, 333=Bharat, 222=Dev, 111=Aditya}

Example: Iterate through Java TreeMap

We can iterate through all entries in the TreeMap by using the entrySet() method. To get only the keys, we can use either the keySet() method or the navigableKeySet() method.

import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class IterateTreeMap {

  public static void main(String[] args) {
    TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
    tm.put(111, "Aditya");
    tm.put(333, "Bharat");
    tm.put(222, "Dev");
    tm.put(555, "Hari");
    tm.put(444, "Charan");
    
    System.out.println("Iterate using Entry Set:");
    for(Map.Entry<Integer,String> m: tm.entrySet())
      System.out.println(m.getKey() + " " + m.getValue());
    
    System.out.println("Iterate using KeySet: ");
    for(Integer i: tm.keySet())
      System.out.println(i + " " + tm.get(i));
    
    System.out.println("Iterate through NavigableKeySet: ");
    System.out.println(tm.navigableKeySet());
    
  }

}

Iterate using Entry Set:
111 Aditya
222 Dev
333 Bharat
444 Charan
555 Hari
Iterate using KeySet: 
111 Aditya
222 Dev
333 Bharat
444 Charan
555 Hari
Iterate through NavigableKeySet: 
[111, 222, 333, 444, 555]

Example: headMap, subMap and tailMap methods of Java TreeMap

Below is the example to retrieve a portion of the mapping of the given TreeMap. When we use headMap() method, it retrieves all the entries from the start until the specified key. The tailMap()method retrieves all the entries from the specified key until the end of the map. To retrieve a portion of the mapping entries, we use the subMap() method which returns the entries from the start to the end range specified.

import java.util.TreeMap;

public class TreeMapMethods {

  public static void main(String[] args) {
    TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
    tm.put(111, "Aditya");
    tm.put(333, "Bharat");
    tm.put(222, "Dev");
    tm.put(555, "Hari");
    tm.put(444, "Charan");
    
    System.out.println("Output of headMap method:");
    System.out.println(tm.headMap(333));
    System.out.println(tm.headMap(333, true));
    System.out.println(tm.headMap(333, false));
    
    System.out.println("Output of tailMap method: ");
    System.out.println(tm.tailMap(333));
    System.out.println(tm.tailMap(333, true));
    System.out.println(tm.tailMap(333, false));
    
    System.out.println("Output of subMap method: ");
    System.out.println(tm.subMap(222, 444));
    System.out.println(tm.subMap(222, true, 444, true));
    System.out.println(tm.subMap(222, false, 444, false));
    System.out.println(tm.subMap(222, false, 444, true));
    System.out.println(tm.subMap(222, true, 444, false));

  }

}

Output of headMap method:
{111=Aditya, 222=Dev}
{111=Aditya, 222=Dev, 333=Bharat}
{111=Aditya, 222=Dev}
Output of tailMap method: 
{333=Bharat, 444=Charan, 555=Hari}
{333=Bharat, 444=Charan, 555=Hari}
{444=Charan, 555=Hari}
Output of subMap method: 
{222=Dev, 333=Bharat}
{222=Dev, 333=Bharat, 444=Charan}
{333=Bharat}
{333=Bharat, 444=Charan}
{222=Dev, 333=Bharat}

Example: Replace values in a Java TreeMap

We can replace a particular value in a Java treemap using the replace() method. If the specified key is not found, it does not replace the value and ignores the statement.

import java.util.TreeMap;

public class ReplaceTreeMap {

  public static void main(String[] args) {
    TreeMap<Integer, String> tm = new TreeMap<Integer, String>();
    tm.put(111, "Aditya");
    tm.put(333, "Bharat");
    tm.put(222, "Dev");
    tm.put(555, "Hari");
    tm.put(444, "Charan");
    
    tm.replace(333, "Banu");
    tm.replace(444, "Charan", "Chandru");
    tm.replace(123, "Test");
    System.out.println("Values after replace method: \n" + tm);

  }

}

Values after replace method: 
{111=Aditya, 222=Dev, 333=Banu, 444=Chandru, 555=Hari}

Difference between TreeMap and HashMap in Java

Reference