ConcurrentNavigableMap Interface in Java

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.

The Hierarchy of ConcurrentNavigableMap

It implements ConcurrentMap<K,​ V>, Map<K, ​V>, NavigableMap<K,​ V>, SortedMap<K,​ V> interfaces. ConcurrentSkipListMap implements ConcurrentNavigableMap.

Example:

Java

// Java Program to demonstrate the
// ConcurrentNavigableMap Interface
import 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}

Implementing Classes

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 ConcurrentSkipListMap
import 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}

Basic Operations on ConcurrentNavigableMap

1. Adding Elements

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
// ConcurrentNavigableMap
import 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}

2. Removing Elements

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 : {}

3. Accessing the Elements

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]

4. Traversing

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.

Methods of ConcurrentNavigableMap

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
descendingKeySet()	Returns a reverse order NavigableSet view of the keys contained in the map.
descendingMap()	Returns a reverse order view of the mappings in the map.
headMap​(K toKey)	Returns the view of the portion of the map wherein the keys are less than toKey.
headMap​(K toKey, boolean inclusive)	Returns the view of the portion of the map wherein the keys are less than toKey, and equal to toKey if inclusive is true.
keySet()	Returns a NavigableSet view of the keys contained in this map.
navigableKeySet()	Returns a NavigableSet view of the keys contained in this map.
subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)	Returns a view of the portion of the map, keys ranging from fromKey to toKey.
subMap(K fromKey, K toKey)	Returns a view of the portion of the map, keys ranging from fromKey, inclusive, to toKey, exclusive.
tailMap(K fromKey)	Returns a view of the map wherein the keys are greater than fromKey.
tailMap(K fromKey, boolean inclusive)	Returns a view of the map wherein the keys are greater than fromKey, and equal to if inclusive is true.

Methods declared in interface java.util.concurrent.ConcurrentMap

METHOD	DESCRIPTION
compute​(K key, BiFunction<? super K, ​? super V,​? extends V> remappingFunction)	Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping).
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)	If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.
forEach​(BiConsumer<? super K,​? super V> action)	Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.
getOrDefault​(Object key, V defaultValue)	Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
merge​(K key, V value, BiFunction<? super V ,​? super V,​? extends V> remappingFunction)	If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value.
putIfAbsent​(K key, V value)	If the specified key is not already associated with a value, associates it with the given value.
remove​(Object key, Object value)	Removes the entry for a key only if currently mapped to a given value.
replace​(K key, V value)	Replaces the entry for a key only if currently mapped to some value.
replace​(K key, V oldValue, V newValue)	Replaces the entry for a key only if currently mapped to a given value.
replaceAll​(BiFunction<? super K,​? super V ,​? extends V> function)	Replaces each entry’s value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.

Methods declared in interface java.util.Map

METHOD	DESCRIPTION
clear()	Removes all of the mappings from this map (optional operation).
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.
equals​(Object o)	Compares the specified object with this map for equality.
get​(Object key)	Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
hashCode()	Returns the hash code value for this map.
isEmpty()	Returns true if this map contains no key-value mappings.
put​(K key, V value)	Associates the specified value with the specified key in this map (optional operation).
putAll​(Map<? extends K,​? extends V> m)	Copies all of the mappings from the specified map to this map (optional operation).
remove​(Object key)	Removes the mapping for a key from this map if it is present (optional operation).
size()	Returns the number of key-value mappings in this map.

Methods declared in interface java.util.NavigableMap

METHOD	DESCRIPTION
ceilingEntry​(K key)	Returns a key-value mapping associated with the least key greater than or equal to the given key, or null if there is no such key.
ceilingKey​(K key)	Returns the least key greater than or equal to the given key, or null if there is no such key.
firstEntry()	Returns a key-value mapping associated with the least key in this map, or null if the map is empty.
floorEntry​(K key)	Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.
floorKey​(K key)	Returns the greatest key less than or equal to the given key, or null if there is no such key.
higherEntry​(K key)	Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.
higherKey​(K key)	Returns the least key strictly greater than the given key, or null if there is no such key.
lastEntry()	Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
lowerEntry​(K key)	Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.
lowerKey​(K key)	Returns the greatest key strictly less than the given key, or null if there is no such key.
pollFirstEntry()	Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty.
pollLastEntry()	Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.

Methods declared in interface java.util.SortedMap

METHOD	DESCRIPTION
comparator()	Returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.
entrySet()	Returns a Set view of the mappings contained in this map.
firstKey()	Returns the first (lowest) key currently in this map.
lastKey()	Returns the last (highest) key currently in this map.
values()	Returns a Collection view of the values contained in this map.