ConcurrentNavigableMap Interface in Java - GeeksforGeeks

19 Dec, 2021
The ConcurrentNavigableMap interface is a member of the Java Collection Framework. It extends from the NavigableMap interface and ConcurrentMap interface. The ConcurrentNavigableMap provides thread-safe access to map elements along with providing convenient navigation methods. It belongs to java.util.concurrent package.
Declaration:
public interface ConcurrentNavigableMap<K,V> extends ConcurrentMap<K,V>, NavigableMap<K,V>
Here, K is the key Object type and V is the value Object type.
It implements ConcurrentMap<K,​ V>, Map<K, ​V>, NavigableMap<K,​ V>, SortedMap<K,​ V> interfaces. ConcurrentSkipListMap implements ConcurrentNavigableMap.
Java
// Java Program to demonstrate the// ConcurrentNavigableMap Interfaceimport java.util.concurrent.ConcurrentNavigableMap;import java.util.concurrent.ConcurrentSkipListMap; public class GFG {     public static void main(String[] args)    {         // Instantiate an object        // Since ConcurrentNavigableMap        // is an interface so We use        // ConcurrentSkipListMap        ConcurrentNavigableMap<Integer, String> cnmap            = new ConcurrentSkipListMap<Integer, String>();         // Add elements using put() method        cnmap.put(1, "First");        cnmap.put(2, "Second");        cnmap.put(3, "Third");        cnmap.put(4, "Fourth");         // Print the contents on the console        System.out.println(            "Mappings of ConcurrentNavigableMap : "            + cnmap);         System.out.println("HeadMap(3): "                           + cnmap.headMap(3));        System.out.println("TailMap(3): "                           + cnmap.tailMap(3));        System.out.println("SubMap(1, 3): "                           + cnmap.subMap(1, 3));    }}
 Output:
Mappings of ConcurrentNavigableMap : {1=First, 2=Second, 3=Third, 4=Fourth}
HeadMap(3): {1=First, 2=Second}
TailMap(3): {3=Third, 4=Fourth}
SubMap(1, 3): {1=First, 2=Second}
The ConcurrentNavigableMap has one implementing class which is ConcurrentSkipListMap class. The ConcurrentSkipListMap is a scalable implementation of the ConcurrentNavigableMap interface. The keys in ConcurrentSkipListMap are sorted by natural order or by using a Comparator at the time of construction of the object. The ConcurrentSkipListMap has the expected time cost of log(n) for insertion, deletion, and searching operations. It is a thread-safe class, therefore, all basic operations can be accomplished concurrently. Syntax:
ConcurrentSkipListMap< ? , ? > objectName = new ConcurrentSkipListMap< ? , ? >();
Example: In the code given below, we simply instantiate an object of the ConcurrentSkipListMap class named cslmap. The put() method is used to add elements and remove() to delete elements. For the remove() method the syntax is objectname.remove(Object key). The keySet() shows all the keys in the map (description in the method table given above).
Java
// Java Program to demonstrate the ConcurrentSkipListMapimport java.util.concurrent.*; public class ConcurrentSkipListMapExample {     public static void main(String[] args)    {         // Instantiate an object of        // ConcurrentSkipListMap named cslmap        ConcurrentSkipListMap<Integer, String> cslmap            = new ConcurrentSkipListMap<Integer, String>();         // Add elements using put()        cslmap.put(1, "Geeks");        cslmap.put(2, "For");        cslmap.put(3, "Geeks");         // Print the contents on the console        System.out.println(            "The ConcurrentSkipListMap contains: "            + cslmap);         // Print the key set using keySet()        System.out.println(            "\nThe ConcurrentSkipListMap key set: "            + cslmap.keySet());         // Remove elements using remove()        cslmap.remove(3);         // Print the contents on the console        System.out.println(            "\nThe ConcurrentSkipListMap contains: "            + cslmap);    }}
Output:
The ConcurrentSkipListMap contains: {1=Geeks, 2=For, 3=Geeks}

The ConcurrentSkipListMap key set: [1, 2, 3]

The ConcurrentSkipListMap contains: {1=Geeks, 2=For}
 
To add elements to a ConcurrentNavigableMap we can use any methods of the Map interface. The code below shows how to use them. You can observe in the code that when no Comparator is provided at the time of construction, the natural order is followed.
Java
// Java Program for adding elements to a// ConcurrentNavigableMapimport java.util.concurrent.*; public class AddingElementsExample {     public static void main(String[] args)    {         // Instantiate an object        // Since ConcurrentNavigableMap is an interface        // We use ConcurrentSkipListMap        ConcurrentNavigableMap<Integer, String> cnmap            = new ConcurrentSkipListMap<Integer, String>();         // Add elements using put()        cnmap.put(8, "Third");        cnmap.put(6, "Second");        cnmap.put(3, "First");         // Print the contents on the console        System.out.println(            "Mappings of ConcurrentNavigableMap : "            + cnmap);    }}
 Output:
Mappings of ConcurrentNavigableMap : {3=First, 6=Second, 8=Third}
To remove elements as well we use methods of the Map interface, as ConcurrentNavigableMap is a descendant of Map.
Java
// Java Program for deleting// elements from ConcurrentNavigableMap import java.util.concurrent.*; public class RemovingElementsExample {     public static void main(String[] args)    {         // Instantiate an object        // Since ConcurrentNavigableMap        // is an interface        // We use ConcurrentSkipListMap        ConcurrentNavigableMap<Integer, String> cnmap            = new ConcurrentSkipListMap<Integer, String>();         // Add elements using put()        cnmap.put(8, "Third");        cnmap.put(6, "Second");        cnmap.put(3, "First");        cnmap.put(11, "Fourth");         // Print the contents on the console        System.out.println(            "Mappings of ConcurrentNavigableMap : "            + cnmap);         // Remove elements using remove()        cnmap.remove(6);        cnmap.remove(8);         // Print the contents on the console        System.out.println(            "\nConcurrentNavigableMap, after remove operation : "            + cnmap);         // Clear the entire map using clear()        cnmap.clear();        System.out.println(            "\nConcurrentNavigableMap, after clear operation : "            + cnmap);    }}
 Output:
Mappings of ConcurrentNavigableMap : {3=First, 6=Second, 8=Third, 11=Fourth}

ConcurrentNavigableMap, after remove operation : {3=First, 11=Fourth}

ConcurrentNavigableMap, after clear operation : {}
We can access the elements of a ConcurrentNavigableMap using get() method, the example of this is given below.
Java
// Java Program for accessing// elements in a ConcurrentNavigableMap import java.util.concurrent.*; public class AccessingElementsExample {     public static void main(String[] args)    {        // Instantiate an object        // Since ConcurrentNavigableMap is an interface        // We use ConcurrentSkipListMap        ConcurrentNavigableMap<Integer, String> cnmap            = new ConcurrentSkipListMap<Integer, String>();         // Add elements using put()        cnmap.put(8, "Third");        cnmap.put(6, "Second");        cnmap.put(3, "First");        cnmap.put(11, "Fourth");         // Accessing the elements using get()        // with key as a parameter        System.out.println(cnmap.get(3));        System.out.println(cnmap.get(6));        System.out.println(cnmap.get(8));        System.out.println(cnmap.get(11));         // Display the set of keys using keySet()        System.out.println(            "\nThe ConcurrentNavigableMap key set: "            + cnmap.keySet());    }}
 Output:
First
Second
Third
Fourth

The ConcurrentNavigableMap key set: [3, 6, 8, 11]
We can use the Iterator interface to traverse over any structure of the Collection Framework. Since Iterators work with one type of data we use .Entry< ? , ? > to resolve the two separate types into a compatible format. Then using the next() method we print the elements of the ConcurrentNavigableMap.
Java
// Java Program for traversing a ConcurrentNavigableMap import java.util.concurrent.*;import java.util.*; public class TraversalExample {     public static void main(String[] args)    {         // Instantiate an object        // Since ConcurrentNavigableMap is an interface        // We use ConcurrentSkipListMap        ConcurrentNavigableMap<Integer, String> cnmap            = new ConcurrentSkipListMap<Integer, String>();         // Add elements using put()        cnmap.put(8, "Third");        cnmap.put(6, "Second");        cnmap.put(3, "First");        cnmap.put(11, "Fourth");         // Create an Iterator over the        // ConcurrentNavigableMap        Iterator<ConcurrentNavigableMap                     .Entry<Integer, String> > itr            = cnmap.entrySet().iterator();         // The hasNext() method is used to check if there is        // a next element The next() method is used to        // retrieve the next element        while (itr.hasNext()) {            ConcurrentNavigableMap                .Entry<Integer, String> entry                = itr.next();            System.out.println("Key = " + entry.getKey()                               + ", Value = "                               + entry.getValue());        }    }}
 Output:
Key = 3, Value = First
Key = 6, Value = Second
Key = 8, Value = Third
Key = 11, Value = Fourth
Note: Every time that we say ‘elements of ConcurrentNavigableMap’, it has to be noted that the elements are actually stored in the object of an implementing class of ConcurrentNavigableMap in this case ConcurrentSkipListMap.
ConcurrentNavigableMap inherits methods from the Map interface, SortedMap interface, ConcurrentMap interface, NavigableMap interface. The basic methods for adding elements, removing elements, and traversal are given by the parent interfaces. The methods of the ConcurrentNavigableMap are given in the following table. Here,
K – The type of the keys in the map.
V – The type of values mapped in the map.
Method
Description
METHOD
DESCRIPTION
compute​(K key, BiFunction<? super K,
​? super V,​? extends V> remappingFunction)
computeIfAbsent​(K key, Function<? super K,​
? extends V> mappingFunction)
If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value 
using the given mapping function and enters it into this map unless null.
computeIfPresent​(K key, BiFunction<? super K,​? 
super V,​? extends V> remappingFunction)
merge​(K key, V value, BiFunction<? super V
,​? super V,​? extends V> remappingFunction)
replaceAll​(BiFunction<? super K,​? super V
,​? extends V> function)
METHOD
DESCRIPTION
METHOD
DESCRIPTION
METHOD
DESCRIPTION
Ganeshchowdharysadanala
sweetyty
arorakashish0911
Java-Collections
Java-ConcurrentNavigableMap
Java
Java
Java-Collections
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Constructors in Java
Stream In Java
Exceptions in Java
Different ways of Reading a text file in Java
Functional Interfaces in Java
Java Programming Examples
StringBuilder Class in Java with Examples
Checked vs Unchecked Exceptions in Java
Comparator Interface in Java with Examples
Strings in Java