TreeMap is a form of map implementation in Java. It works on the red and black tree data structure. Let us have a detailed look at different aspects of TreeMap. Let us cover the following topics one by one:
- Features
- Class Declaration
- Class Parameters
- Internal working of TreeMap in Java
- Constructors of TreeMap Class with Examples
- Various Operations on TreeMap in Java
- Methods of TreeMap Class
- How to Achieve Synchronization in TreeMap in Java?
- Some Examples of TreeMap in Java
- Advantages of TreeMap in Java
- Points to Remember
Check out our free courses to get an edge over the competition.
TreeMap in Java Features:
- TreeMap in Java implements the specified types of map interfaces. These include SortedMap and NavigableMap. It further extends to AbstractMap class.
- TreeMap in Java doesn’t support Entry.setValue methods. Thus, the entry pairs returned by the TreeMap methods and their views represent the snapshots of the mappings at the time of their creation.
- NullPointerException is thrown in TreeMap in Java as it doesn’t allow null keys like Map. There are options to associate multiple null values to different keys.
- TreeMap is a member of the Java Collections Framework.
Learn Software Development Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs or Masters Programs to fast-track your career.
TreeMap in Java Class Declaration:
The declaration for java.util.TreeMap class is:
public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable
TreeMap in Java Class Parameters:
The parameters for java.util.TreeMap class are:
- V: It is the type of mapped values.
- K: It is the key type maintained by the map.
Check out upGrad’s Advanced Certification in DevOps
Internal working of TreeMap in Java
The methods of TreeMap return the iterators that are fail-fast in nature while getting keyset and values. Hence, there are chances of concurrent modification exceptions. However, TreeMap in Java is based on a red and black tree data structure. Each node in this data tree has:
- 3 Variables (K key= Key, V value= Value, boolean color= Color)
- 3 References (Entry left= Left, Entry right= Right, Entry parent= Parent)
Constructors of TreeMap Class with Examples:
The primary constructors in TreeMap in Java are:
-
TreeMap()
This constructor is used to design an empty treemap. This blank treemap is arranged using the normal order of its key. For example
Input:
Output:
Check out upGrad’s Advanced Certification in Cyber Security
-
TreeMap(Comparator<? super K> comparator)
In this comparator, a tree-based map that is empty is constructed and is sorted using this comparator comp. For example
Input:
Output:
-
TreeMap Map M
It is used for the initialization of a TreeMap with the entries of the given map M. This is sorted with the natural number of the keys. For example
Input:
Output:
-
TreeMap (SortedMap sm)
It is used in initialization of a TreeMap with the passes from the given sorted map. These entries are stored in the identical order as the given sorted map. For example
Input:
Output:
Various Operations on TreeMap in Java:
There are certain frequently used operations in the TreeMap. With the full restriction on the object types that can be stored in the TreeMap, let us check a few of these operations:
-
Adding Elements
The put () method is used to add elements in TreeMap. The insertion order is not retained in the TreeMap. But for each element, the keys are compared and then sorted in ascending order internally. For Example
Input:
Output:
-
Removing Elements
The remove () method is used to remove the element from the TreeMap in Java. It takes the key values and removes the mapping for the key from this treemap if it is present in it. For example
Input
Output
-
Changing Elements
The elements can be changed after addition with the same put () method that is used for adding the elements. The value of the key can be changed by simply adding the updated value for the key for wish change is required. This is achieved as all elements in the TreeMap are indexed using the keys only. For example
Input
Output:
-
Iterating Through the TreeMap
The most commonly used method to iterate through the TreeMap is to use a for-each loop and fetch the keys. Apart from this, there are multiple other options as well. For example
Input:
Output
Methods of TreeMap Class:
TreeMap in Java can be achieved using the following methods:
- clear() Method or void clear() Method
It clears the TreeMap by removing all mappings from it at once.
- clone() Method or Object clone() Method
It reverts a shallow copy of this TreeMap.
- containsKey (Object Key) Method or boolean containsKey(Object key) Method
It returns to a true value if the map contains a mapping for the identified key.
- containsValue (Object Value) Method or boolean containsValue(Object value) Method
It returns to a true value if this map maps one or more than one keys for the described key.
- entrySet() Method
It returns to a set view of all mappings contained in this map.
- firstKey() Method or K firstKey() Method
It returns the first, i.e. the first lowest key that is currently present in this sorted map.
- keySet() Method or Set keyset() Method
It returns to the set views of the keys that are contained in the TreeMap.
- K ceilingKey (K key) Method
It returns to the least key, greater than the definite key or returns to null if no such key exists.
- K higherKey (K key) Method
It returns to the true if this map contains a mapping for the particular.
- K lowerKey (K key) Method
It returns to the greatest key that is strictly less than the given key or returns to null if there is no such key.
- headMap(Object key_value) Method
It returns a view of that portion of the map that is strictly less than the parameter key-value.
- lastKey() Method or K lastKey() Method
It returns to the last, i.e. the last highest key that is currently present in this sorted map.
- put(Object key, Object value) Method
It is used to insert a new mapping into a map.
- V put(K key, V value) Method
It is used to insert the specified value to the particular in the map.
- putAll(Map map) Method
It copies all mappings from the prescribed map to this map.
- remove( Object key) Method
It removes the mapping from the TreeMap for this key if present.
- size() Method
It returns to the number of key-value mappings in this map.
- values() Method
It returns to a collection view of the values contained in this map.
- Collection values() Method
It returns to a collection view of the values contained in the map.
- int size() Method
It returns to the number of pairs of key-value existing in the hashtable.
- V remove(Object key) Method
It removes the key-value pair of the prescribed key from the map.
- V replace(K key, V value) Method
It is used to replace a specified value for a particular in the map.
- Set<Map.Entry<K,V>> entrySet() Method
It returns to the set view of mappings that are contained in the map.
- subMap((K startKey, K endKey) Method
It returns a portion of the map. This portion is of the keys that range from startKey, inclusive, to endKey, exclusive.
- Comparator<?super K> comparator() Method
It returns to the comparator that sequences the key in an order or returns null if the map makes use of the natural ordering.
- get(Object key) Method or V get(Object key) Method
It returns the value to which this map maps the defined key.
- Map.Entry<K,V> ceilingEntry( K key) Method
It returns to the key-value pair having the minimum key, equal to or greater than the prescribed key or returns to null if there exists no such key.
- Map.Entry firstEntry() Method
It returns to the key-value pair having the minimum key.
- Map.Entry lastEntry() Method
It returns to the key-value pair having the greatest key returns to null if no such key exists.
- Map.Entry<K,V> floorEntry(K key) Method
It returns to the greatest key, equal to or lesser than the prescribed key or returns to null if there exists no such key.
- void forEach(BiConsumer<? Super K,? super V> action) Method
It performs the specified action for every entry in the map till all the entries have been handled or the action pitches an exception.
- void replaceAll(Bifunction<? Super K,? super V,> extends V> function) Method
It is called to replace the value of each entry with the result of the given function invoking on that input until all passes have been handled, or an exception is thrown by the function.
- void putAll(Map<? extends K,? extends V> map) Method
It copies all the key-value pair from one map to another map.
- SortedMap<K,V> headMap(K toKey) Method
It returns to the pairs of key-valuewhose keys are firmly less than toKey.
- SortedMap<K,V> tailMap(K fromKey) Method
It returns to the pairs of key-valuewhose keys are equal to or greater than fromKey.
- SortedMap<K,V> subMap(K fromKey, K toKey) Method
It returns to the pairs of key-valuewhose keys are in the range of inclusive fromKey to exclusive toKey.
- NavigableSet<K> navigableKeySet() Method
It returns to the NavigableSet view of the keys contained in this map.
- NavigableMap<K,V> headMap( K toKey, boolean inclusive)
It returns the pairs of key-valuewith keys equal to or lesser than if inclusive is true to toKey.
- NavigableMap<K,V> tailMap( K tfromKey, boolean inclusive)
It returns to the pairs of key-valuewith keys equal to or greater than if inclusive is true to fromKey.
- NavigableSet<K> descendingKeySet() Method
It returns to a reverse order NavigableSet view of the keys present in the map.
- NavigableMap<K,V> descendingMap() Method
It returns to the specified pairs of the key-valuein descending pattern.
- NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, Boolean toInclusive) Method
It returns to the pairs of key-valuewhose keys range from fromKey to toKey.
- Map.Entry<K,V> higherEntry(K key) Method
It returns to the least key strictly greater than the given key or returns to null if there exists no such key.
- Map.Entry<K,V> lowerEntry(K key) Method
It returns to a key-value mapping connected with the greatest key firmly less than the given key or returns to null if there exists no such key.
- Map.Entry<K,V> pollFirstEntry() Method
It removes and returns to a key-value mapping linked with the minimum key in the map or returns to null if the map is empty.
- Map.Entry<K,V> pollLastEntry() Method
It removes and returns to a key-value mapping allied with the greatest key in the map or returns to null if the map is empty.
- boolean replace( K key, V oldValue, V newValue) Method
It replaces the old value with the new value for the prescribed key.
How to Achieve Synchronization in TreeMap in Java?
The implementation of TreeMap is not synchronized. Thus, there is a need for external synchronization that is accomplished using Collections.synchronizedSortedSet method. It can be synchronized as:
SortedMap m= Collections.synchronizedSortedMap(new TreeMap(…));
It is required in case multiple threads access a tree set concurrently and at least one of the threads modifies the set.
TreeMap in Java Examples:
- Example: Book
Input:
Output:
2. Example: SortedMap
Input:
Output:
3. Example: NavigableMap
Input:
Output:
4. Example: Remove
Input:
Output:
Advantages of TreeMap in Java
TreeMap in Java works internally on the red-black tree. The red-black tree is a data structure that is in the form of a self-balancing binary search tree. The paint demarcation of red and black allows the tree to be significantly balanced at all times. Thus, it is helpful in frequent insertion and deletion functions. Also, a red and black tree data structure has low constants during the wide eventualities range. The peak of this red and black tree is O or Logn; n is the variety of nods within the tree. Hence, you can define a custom sort order in it.
TreeMap in Java is based on the NavigableMap implementation. This map can be sorted using the natural order of keys as well. You can achieve the same by using a comparator that is provided at the time of map creation. The concerned constructor is used.
Another big benefit of TreeMap in Java is that all the basic functions of find(), remove(), and add() have run-time complexity of O, i.e., log n. Thus, it is super-easy for the users to perform functions like; find “largest,” find “smallest,” etc. Further, you can achieve synchronization in TreeMap. It provides complete control over how the keys should be sorted.
TreeMap in Java- Points to Remember
- It contains only unique elements.
- It is non-synchronized.
- It can’t hold a null key but can have multiple null values.
- It maintains ascending order.
- It contains values that are based on the key only.
- It implements the NavigableMap interface.
- It extends AbstractMap class.
- It allows homogeneous values as a key because of sorting.
- It uses a self-balancing binary search tree.
- It is used when we require pairs of key-valuein sorted order.
Our Executive Post Graduate Programme in Software Development – Specialisation in Full Stack Development course demands no prior coding experience and trains you on MERN stack and microservices, JavaScript, and more. We enable this by providing you 1:1 career mentorship sessions with industry mentors, an opportunity to work on the capstone project and solidify your learnings, and a peer group that is there to support you 24×7! Check out the course page and get yourself enrolled soon!
