TreeMap in Java

The TreeMap in Java is used to implement Map interface and NavigableMap along with the AbstractMap Class. The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time, depending on which constructor is used. This proves to be an efficient way of sorting and storing the key-value pairs. The storing order maintained by the treemap must be consistent with equals just like any other sorted map, irrespective of the explicit comparators. The treemap implementation is not synchronized in the sense that if a map is accessed by multiple threads, concurrently and at least one of the threads modifies the map structurally, it must be synchronized externally.

Map and Treemap in Java

Example: The following implementation demonstrates how to create, insert, and traverse through the TreeMap.

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java code to show creation, insertion,
// searching, and traversal in a TreeMap
  
import java.util.*;
import java.util.concurrent.*;
  
public class TreeMapImplementation {
  
    // Declaring a TreeMap
    static TreeMap<Integer, String> tree_map;
  
    // Function to create TreeMap
    static void create()
    {
        // Creating an empty TreeMap
        tree_map
            = new TreeMap<Integer, String>();
  
        System.out.println(
            "TreeMap successfully"
            + " created");
    }
  
    // Function to Insert values in
    // the TreeMap
    static void insert()
    {
        // Mapping string values to int keys
        tree_map.put(10, "Geeks");
        tree_map.put(15, "4");
        tree_map.put(20, "Geeks");
        tree_map.put(25, "Welcomes");
        tree_map.put(30, "You");
  
        System.out.println(
            "\nElements successfully"
            + " inserted in the TreeMap");
    }
  
    // Function to search a key in TreeMap
    static void search(int key)
    {
  
        // Checking for the key
        System.out.println(
            "\nIs key \""
            + key + "\" present? "
            + tree_map.containsKey(key));
    }
  
    // Function to search a value in TreeMap
    static void search(String value)
    {
  
        // Checking for the value
        System.out.println(
            "\nIs value \""
            + value + "\" present? "
            + tree_map.containsValue(value));
    }
  
    // Function to display the elements in TreeMap
    static void display()
    {
        // Displaying the TreeMap
        System.out.println(
            "\nDisplaying the TreeMap:");
  
        System.out.println(
            "TreeMap: " + tree_map);
    }
  
    // Function to traverse TreeMap
    static void traverse()
    {
        System.out.println("\nTraversing the TreeMap:");
        for (Map.Entry<Integer, String> e : tree_map.entrySet())
            System.out.println(e.getKey()
                               + " "
                               + e.getValue());
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        // Creating the TreeMap
        create();
  
        // Inserting values in the TreeMap
        insert();
  
        // Search key "50" in the TreeMap
        search(50);
  
        // Search value "Geeks" in the TreeMap
        search("Geeks");
  
        // Display the elements in TreeMap
        display();
  
        // Traverse the TreeMap
        traverse();
    }
}

chevron_right


Output:

TreeMap successfully created
Elements successfully inserted in the TreeMap
Is key "50" present? false
Is value "Geeks" present? true
Displaying the TreeMap:
TreeMap: {10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You}
Traversing the TreeMap:
10 Geeks
15 4
20 Geeks
25 Welcomes
30 You

Performing Various Operations on TreeMap

After the introduction of Generics in Java 1.5, it is possible to restrict the type of object that can be stored in the TreeMap. Now, let’s see how to perform a few frequently used operations on the TreeMap.



1. Adding Elements: In order to add an element to the TreeMap, we can use the put() method. However, the insertion order is not retained in the TreeMap. Internally, for every element, the keys are compared and sorted in the ascending order.

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate
// the working of TreeMap
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Default Initialization of a
        // TreeMap
        TreeMap tm1 = new TreeMap();
  
        // Initialization of a TreeMap
        // using Generics
        TreeMap<Integer, String> tm2
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm1.put(3, "Geeks");
        tm1.put(2, "For");
        tm1.put(1, "Geeks");
  
        tm2.put(new Integer(3), "Geeks");
        tm2.put(new Integer(2), "For");
        tm2.put(new Integer(1), "Geeks");
  
        System.out.println(tm1);
        System.out.println(tm2);
    }
}

chevron_right


Output:

{1=Geeks, 2=For, 3=Geeks}
{1=Geeks, 2=For, 3=Geeks}

2. Changing Elements: After adding the elements if we wish to change the element, it can be done by again adding the element with the put() method. Since the elements in the treemap are indexed using the keys, the value of the key can be changed by simply inserting the updated value for the key for which we wish to change.

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate
// the working of TreeMap
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Initialization of a TreeMap
        // using Generics
        TreeMap<Integer, String> tm
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm.put(3, "Geeks");
        tm.put(2, "Geeks");
        tm.put(1, "Geeks");
  
        System.out.println(tm);
  
        tm.put(2, "For");
  
        System.out.println(tm);
    }
}

chevron_right


Output:

{1=Geeks, 2=Geeks, 3=Geeks}
{1=Geeks, 2=For, 3=Geeks}

3. Removing Element: In order to remove an element from the TreeMap, we can use the remove() method. This method takes the key value and removes the mapping for the key from this treemap if it is present in the map.

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate
// the working of TreeMap
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Initialization of a TreeMap
        // using Generics
        TreeMap<Integer, String> tm
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm.put(3, "Geeks");
        tm.put(2, "Geeks");
        tm.put(1, "Geeks");
        tm.put(4, "For");
  
        System.out.println(tm);
  
        tm.remove(4);
  
        System.out.println(tm);
    }
}

chevron_right


Output:

{1=Geeks, 2=Geeks, 3=Geeks, 4=For}
{1=Geeks, 2=Geeks, 3=Geeks}

4. Iterating through the TreeMap: There are multiple ways to iterate through the Map. The most famous way is to use a for-each loop and get the keys. The value of the key is found by using the getValue() method.

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate
// the working of TreeMap
  
import java.util.*;
class GFG {
    public static void main(String args[])
    {
        // Initialization of a TreeMap
        // using Generics
        TreeMap<Integer, String> tm
            = new TreeMap<Integer, String>();
  
        // Inserting the Elements
        tm.put(3, "Geeks");
        tm.put(2, "For");
        tm.put(1, "Geeks");
  
        for (Map.Entry mapElement : tm.entrySet()) {
            int key
                = (int)mapElement.getKey();
  
            // Finding the value
            String value
                = (String)mapElement.getValue();
  
            System.out.println(key + " : "
                               + value);
        }
    }
}

chevron_right


Output:



1 : Geeks
2 : For
3 : Geeks

Features of a TreeMap:

Some important features of the treemap are:

  1. This class is a member of Java Collections Framework.
  2. The class implements Map interfaces including NavigableMap, SortedMap and extends AbstractMap class.
  3. TreeMap in Java does not allow null keys (like Map) and thus a NullPointerException is thrown. However, multiple null values can be associated with different keys.
  4. Entry pairs returned by the methods in this class and its views represent snapshots of mappings at the time they were produced. They do not support the Entry.setValue method.

Synchronized TreeMap:

The implementation of a TreeMap is not synchronized. This means that if multiple threads access a tree set concurrently, and at least one of the threads modifies the set, it must be synchronized externally. This is typically accomplished by using the Collections.synchronizedSortedSet method. This is best done at the creation time, to prevent accidental unsynchronized access to the set. This can be done as:

SortedMap m = Collections.synchronizedSortedMap(new TreeMap(…));

How Does the TreemMap work Internally?

The methods in a TreeMap while getting keyset and values, return an Iterator that are fail-fast in nature. Thus, any concurrent modification will throw ConcurrentModificationException. A TreeMap is based upon a redblack tree data structure. Each node in the tree has:

  • 3 Variables (K key=Key, V value=Value, boolean color=Color)
  • 3 References (Entry left = Left, Entry right = Right, Entry parent = Parent)

Treemap Internal Working

Constructors in TreeMap

In order to create a TreeMap, we need to create an object of the TreeMap class. The TreeMap class consists of various constructors that allow the possible creation of the TreeMap. The following are the constructors available in this class:

1. TreeMap(): This constructor is used to build an empty treemap that will be sorted by using the natural order of its keys. Let’s understand this with an example:



filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate an
// example of TreeMap using the
// default constructor
  
import java.util.*;
import java.util.concurrent.*;
  
public class TreeMapImplementation {
  
    // Function to show TreeMap()
    // constructor example
    static void Example1stConstructor()
    {
        // Creating an empty TreeMap
        TreeMap<Integer, String> tree_map
            = new TreeMap<Integer, String>();
  
        // Mapping string values to int keys
        tree_map.put(10, "Geeks");
        tree_map.put(15, "4");
        tree_map.put(20, "Geeks");
        tree_map.put(25, "Welcomes");
        tree_map.put(30, "You");
  
        // Displaying the TreeMap
        System.out.println("TreeMap: "
                           + tree_map);
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        System.out.println("TreeMap using "
                           + "TreeMap() constructor:\n");
  
        Example1stConstructor();
    }
}

chevron_right


Output:

TreeMap using TreeMap() constructor:
TreeMap: {10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You}

2. TreeMap(Comparator comp): This constructor is used to build an empty TreeMap object in which the elements will need an external specification of the sorting order. Let’s understand this with an example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate
// an example of TreeMap using
// a comparator constructor
  
import java.util.*;
import java.util.concurrent.*;
  
// A class to represent a student.
class Student {
    int rollno;
    String name, address;
  
    // Constructor
    public Student(int rollno, String name,
                   String address)
    {
        this.rollno = rollno;
        this.name = name;
        this.address = address;
    }
  
    // Used to print student details
    // in main()
    public String toString()
    {
        return this.rollno + " "
            + this.name + " "
            + this.address;
    }
}
  
// Comparator implementattion
class Sortbyroll
    implements Comparator<Student> {
  
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student a, Student b)
    {
        return a.rollno - b.rollno;
    }
}
  
public class TreeMapImplementation {
  
    static void Example2ndConstructor()
    {
        // Creating an empty TreeMap
        TreeMap<Student, Integer> tree_map
            = new TreeMap<Student, Integer>(new Sortbyroll());
  
        // Mapping string values to int keys
        tree_map.put(new Student(111, "bbbb",
                                 "london"),
                     2);
        tree_map.put(new Student(131, "aaaa",
                                 "nyc"),
                     3);
        tree_map.put(new Student(121, "cccc",
                                 "jaipur"),
                     1);
  
        // Displaying the TreeMap
        System.out.println("TreeMap: "
                           + tree_map);
    }
  
    public static void main(String[] args)
    {
  
        System.out.println("TreeMap using "
                           + "TreeMap(Comparator)"
                           + " constructor:\n");
        Example2ndConstructor();
    }
}

chevron_right


Output:

TreeMap using TreeMap(Comparator) constructor:
TreeMap: {111 bbbb london=2, 121 cccc jaipur=1, 131 aaaa nyc=3}

3. TreeMap(Map M): This constructor is used to initialize a TreeMap with the entries from the given map M which will be sorted by using the natural order of the keys. Let’s understand this with an example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate an
// example of TreeMap using the
// default constructor
  
import java.util.*;
import java.util.concurrent.*;
  
public class TreeMapImplementation {
  
    static void Example3rdConstructor()
    {
        // Creating a Map
        Map<Integer, String> hash_map
            = new HashMap<Integer, String>();
  
        // Mapping string values to int keys
        hash_map.put(10, "Geeks");
        hash_map.put(15, "4");
        hash_map.put(20, "Geeks");
        hash_map.put(25, "Welcomes");
        hash_map.put(30, "You");
  
        // Creating the TreeMap using the Map
        TreeMap<Integer, String> tree_map
            = new TreeMap<Integer, String>(hash_map);
  
        // Displaying the TreeMap
        System.out.println("TreeMap: "
                           + tree_map);
    }
  
    public static void main(String[] args)
    {
  
        System.out.println("TreeMap using "
                           + "TreeMap(Map)"
                           + " constructor:\n");
        Example3rdConstructor();
    }
}

chevron_right


Output:

TreeMap using TreeMap(Map) constructor:
TreeMap: {10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You}

4. TreeMap(SortedMap sm): This constructor is used to initialize a TreeMap with the entries from the given sorted map which will be stored in the same order as the given sorted map. Let’s understand this with an example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to demonstrate an
// example of TreeMap using the
// sortedmap constructor
  
import java.util.*;
import java.util.concurrent.*;
  
public class TreeMapImplementation {
  
    // Function to show
    // TreeMap(SortedMap) constructor example
    static void Example4thConstructor()
    {
        // Creating a SortedMap
        SortedMap<Integer, String> sorted_map
            = new ConcurrentSkipListMap<Integer, String>();
  
        // Mapping string values to int keys
        sorted_map.put(10, "Geeks");
        sorted_map.put(15, "4");
        sorted_map.put(20, "Geeks");
        sorted_map.put(25, "Welcomes");
        sorted_map.put(30, "You");
  
        // Creating the TreeMap using the SortedMap
        TreeMap<Integer, String> tree_map
            = new TreeMap<Integer, String>(sorted_map);
  
        // Displaying the TreeMap
        System.out.println("TreeMap: "
                           + tree_map);
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        System.out.println("TreeMap using "
                           + "TreeMap(SortedMap)"
                           + " constructor:\n");
        Example4thConstructor();
    }
}

chevron_right


Output:

TreeMap using TreeMap(SortedMap) constructor:
TreeMap: {10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You}

Methods in the TreeMap Class

Method Description
clear() The method removes all mappings from this TreeMap and clears the map.
clone() The method returns a shallow copy of this TreeMap.
containsKey(Object key) Returns true if this map contains a mapping for the specified key.
containsValue(Object value) Returns true if this map maps one or more keys to the specified value.
entrySet() Returns a set view of the mappings contained in this map.
firstKey() Returns the first (lowest) key currently in this sorted map.
get(Object key) Returns the value to which this map maps the specified key.
headMap(Object key_value) The method returns a view of the portion of the map strictly less than the parameter key_value.
keySet() The method returns a Set view of the keys contained in the treemap.
lastKey() Returns the last (highest) key currently in this sorted map.
put(Object key, Object value) The method is used to insert a mapping into a map.
putAll(Map map) Copies all of the mappings from the specified map to this map.
remove(Object key) Removes the mapping for this key from this TreeMap if present.
size() Returns the number of key-value mappings in this map.
subMap((K startKey, K endKey) The method returns the portion of this map whose keys range from startKey, inclusive, to endKey, exclusive.
values() Returns a collection view of the values contained in this map.

Attention reader! Don’t stop learning now. Get hold of all the important Java and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : RishabhPrabhu, KaashyapMSK

Article Tags :
Practice Tags :


8


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.