Interfaz ConcurrentNavigableMap en Java

La interfaz ConcurrentNavigableMap es miembro de Java Collection Framework . Se extiende desde la interfaz NavigableMap y la interfaz ConcurrentMap . ConcurrentNavigableMap proporciona acceso seguro para subprocesos a los elementos del mapa junto con métodos de navegación convenientes. Pertenece al paquete java.util.concurrent .

Declaración:

public interface ConcurrentNavigableMap<K,V> extends ConcurrentMap<K,V>, NavigableMap<K,V>

Aquí, K es el tipo de objeto clave y V es el tipo de objeto de valor.

La jerarquía de ConcurrentNavigableMap

Implementa las interfaces ConcurrentMap<K,​ V> , Map<K, ​V> , NavigableMap<K,​ V> , SortedMap<K,​ V> . ConcurrentSkipListMap implementa ConcurrentNavigableMap.

Ejemplo:

// 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));
    }
}

 
Producción:

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}

Implementando Clases

El ConcurrentNavigableMap tiene una clase de implementación que es la clase ConcurrentSkipListMap . ConcurrentSkipListMap es una implementación escalable de la interfaz ConcurrentNavigableMap. Las claves en ConcurrentSkipListMap se clasifican por orden natural o mediante el uso de un comparador en el momento de la construcción del objeto. El ConcurrentSkipListMap tiene el costo de tiempo esperado de log(n) para las operaciones de inserción, eliminación y búsqueda. Es una clase segura para subprocesos, por lo tanto, todas las operaciones básicas se pueden realizar al mismo tiempo.
 
Sintaxis:

ConcurrentSkipListMap< ? , ? > objectName = new ConcurrentSkipListMap< ? , ? >();

Ejemplo : en el código que se proporciona a continuación, simplemente creamos una instancia de un objeto de la clase ConcurrentSkipListMap denominado cslmap. El método put() se usa para agregar elementos y remove() para eliminar elementos. Para el método remove(), la sintaxis es objectname.remove(Object key) . keySet() muestra todas las claves en el mapa (descripción en la tabla de métodos anterior).

// 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);
    }
}

Producción:

The ConcurrentSkipListMap contains: {1=Geeks, 2=For, 3=Geeks}

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

The ConcurrentSkipListMap contains: {1=Geeks, 2=For}

Operaciones básicas en ConcurrentNavigableMap

1. Agregar elementos

Para agregar elementos a un ConcurrentNavigableMap podemos usar cualquier método de la interfaz Map. El siguiente código muestra cómo usarlos. Puede observar en el código que cuando no se proporciona un Comparador en el momento de la construcción, se sigue el orden natural.

// 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);
    }
}

 
Producción:

Mappings of ConcurrentNavigableMap : {3=First, 6=Second, 8=Third}

2. Eliminación de elementos

Para eliminar elementos también usamos métodos de la interfaz Map, ya que ConcurrentNavigableMap es un descendiente de Map.

// 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);
    }
}

 
Producción:

Mappings of ConcurrentNavigableMap : {3=First, 6=Second, 8=Third, 11=Fourth}

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

ConcurrentNavigableMap, after clear operation : {}

3. Accediendo a los Elementos

Podemos acceder a los elementos de un ConcurrentNavigableMap usando el método get(), el ejemplo de esto se da a continuación.

// 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());
    }
}

 
Producción:

First
Second
Third
Fourth

The ConcurrentNavigableMap key set: [3, 6, 8, 11]

4. Atravesando

Podemos usar la interfaz Iterator para atravesar cualquier estructura del marco de colección. Dado que los iteradores funcionan con un tipo de datos, usamos .Entry< ? , ? > para resolver los dos tipos separados en un formato compatible. Luego, usando el método next() imprimimos los elementos del ConcurrentNavigableMap.

// 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());
        }
    }
}

 
Producción:

Key = 3, Value = First
Key = 6, Value = Second
Key = 8, Value = Third
Key = 11, Value = Fourth

Nota: Cada vez que decimos ‘elementos de ConcurrentNavigableMap’, debe tenerse en cuenta que los elementos se almacenan en el objeto de una clase de implementación de ConcurrentNavigableMap en este caso ConcurrentSkipListMap.

Métodos de ConcurrentNavigableMap

ConcurrentNavigableMap hereda métodos de la interfaz Map , la interfaz SortedMap , la interfaz ConcurrentMap y la interfaz NavigableMap . Las interfaces principales proporcionan los métodos básicos para agregar elementos, eliminar elementos y atravesarlos. Los métodos de ConcurrentNavigableMap se proporcionan en la siguiente tabla. Aquí,

• K – El tipo de claves en el mapa.
• V – El tipo de valores mapeados en el mapa.

Métodos declarados en la interfaz java.util.concurrent.ConcurrentMap

Métodos declarados en la interfaz java.util.Map

Métodos declarados en la interfaz java.util.NavigableMap

Métodos declarados en la interfaz java.util.SortedMap