ConcurrentSkipListMap en Java con ejemplos

La clase ConcurrentSkipListMap es miembro de Java Collections Framework . Fue introducido en JDK 1.6, pertenece al paquete java.util.concurrent . ConcurrentSkipListMap es una implementación escalable de ConcurrentNavigableMap . Todos los elementos se ordenan según el orden natural o por el Comparador pasado durante su tiempo de construcción. Esta clase utiliza una variación simultánea de la estructura de datos SkipList que proporciona el costo de tiempo de registro (n) para las operaciones de inserción, eliminación, actualización y acceso. Estas operaciones son seguras para ejecutarse simultáneamente por varios subprocesos. 

Declaración

clase pública ConcurrentSkipListMap<K,​V> extiende AbstractMap<K,​V> implementa ConcurrentNavigableMap<K,​V>, Cloneable, Serializable

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

La jerarquía de ConcurrentSkipListMap

Implementa las interfaces Serializable , Cloneable , ConcurrentMap<K,​V> , ConcurrentNavigableMap<K,​V> , Map<K,​V> , NavigableMap<K,​V> , SortedMap<K,​V> y extiende AbstractMap< Clase K, V> .

Constructores de ConcurrentSkipListMap

1. ConcurrentSkipListMap() : Construye un nuevo mapa vacío, clasificado según el orden natural de las claves.

ConcurrentSkipListMap<K, V> cslm = new ConcurrentSkipListMap<K, V>();

2. ConcurrentSkipListMap​(Comparator<? super K> comparador) : construye un nuevo mapa vacío, ordenado de acuerdo con el comparador especificado.

ConcurrentSkipListMap<K, V> cslm = new ConcurrentSkipListMap​<K, V>(Comparator<? super K> comparador);

3. ConcurrentSkipListMap​(Map<? extends K,​? extends V> m) : Construye un nuevo mapa que contiene las mismas asignaciones que el mapa dado, ordenadas de acuerdo con el orden natural de las claves.

ConcurrentSkipListMap<K, V> cslm = new ConcurrentSkipListMap<K, V>​(Map<? extiende K,​? extiende V> m);

4. ConcurrentSkipListMap​(SortedMap<K,​? extends V> m) : Construye un nuevo mapa que contiene las mismas asignaciones y usa el mismo orden que el mapa ordenado especificado.

ConcurrentSkipListMap​<K, V> cslm = new ConcurrentSkipListMap​<K, V>(SortedMap<K,​? extiende V> m);

Ejemplo

// Java Program to Demonstrate
// ConcurrentSkipListMap
  
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
  
class ConcurrentSkipListMapExample {
    public static void main(String[] args)
    {
        // create an instance of ConcurrentSkipListMap
        ConcurrentSkipListMap<String, String> cslm
            = new ConcurrentSkipListMap<String, String>();
  
        // Add mappings using put method
        cslm.put("3", "Geeks");
        cslm.put("2", "from");
        cslm.put("1", "Hi!");
        cslm.put("5", "Geeks");
        cslm.put("4", "for");
  
        // print to the console
        System.out.println("Initial Map : " + cslm);
  
        // print key-value pair whose key is greater than 2
        System.out.println("ceilingEntry-2: "
                           + cslm.ceilingEntry("2"));
  
        // get the descending key set
        NavigableSet navigableSet = cslm.descendingKeySet();
  
        System.out.println("descendingKeySet: ");
  
        // Iterate through the keySet
        Iterator itr = navigableSet.iterator();
        while (itr.hasNext()) {
            String s = (String)itr.next();
            System.out.println(s);
        }
  
        // print the first mapping
        System.out.println("firstEntry: "
                           + cslm.firstEntry());
  
        // print the last mapping
        System.out.println("lastEntry: "
                           + cslm.lastEntry());
  
        // remove the first mapping and print it
        System.out.println("pollFirstEntry: "
                           + cslm.pollFirstEntry());
  
        // print the first mapping
        System.out.println("now firstEntry: "
                           + cslm.firstEntry());
  
        // remove the last mapping and print it
        System.out.println("pollLastEntry: "
                           + cslm.pollLastEntry());
  
        // print the last mapping
        System.out.println("now lastEntry: "
                           + cslm.lastEntry());
    }
}

Initial Map : {1=Hi!, 2=from, 3=Geeks, 4=for, 5=Geeks}
ceilingEntry-2: 2=from
descendingKeySet: 
5
4
3
2
1
firstEntry: 1=Hi!
lastEntry: 5=Geeks
pollFirstEntry: 1=Hi!
now firstEntry: 2=from
pollLastEntry: 5=Geeks
now lastEntry: 4=for

Operaciones básicas

1. Agregar asignaciones

El método put() de ConcurrentSkipListMap asocia el valor especificado con la clave especificada en este mapa. Si el mapa contenía anteriormente una asignación para la clave, se reemplaza el valor anterior.

// Java Program to demonstrate adding
// mappings to a ConcurrentSkipListMap
  
import java.util.concurrent.*;
  
class AddingMappingsExample {
    public static void main(String[] args)
    {
  
        // Initializing the map
        ConcurrentSkipListMap<Integer, Integer> cslm
            = new ConcurrentSkipListMap<Integer, Integer>();
  
        // Adding elements to this map
        for (int i = 1; i <= 9; i++)
            cslm.put(i, i);
  
        // put() operation on the map
        System.out.println("After put(): " + cslm);
    }
}

After put(): {1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9}

2. Eliminar asignaciones

El método remove() de ConcurrentSkipListMap elimina la asignación de la clave especificada de esta asignación. El método devuelve nulo si no hay una asignación para esa clave en particular. Después de realizar este método, se reduce el tamaño del mapa. Para eliminar la primera entrada y la última entrada del mapa, podemos usar pollFirstEntry() y pollLastEntry() respectivamente.

// Java Program Demonstrate removing
// mappings from ConcurrentSkipListMap
  
import java.util.concurrent.*;
  
class RemovingMappingsExample {
    public static void main(String[] args)
    {
  
        // Initializing the map
        ConcurrentSkipListMap<Integer, Integer> cslm
            = new ConcurrentSkipListMap<Integer, Integer>();
  
        // Adding elements to this map
        for (int i = 1; i <= 6; i++)
            cslm.put(i, i);
  
        // remove() operation on the map
        cslm.remove(5);
  
        // print the modified map
        System.out.println("After remove(): " + cslm);
  
        // remove the first mapping and print it
        System.out.println("pollFirstEntry: "
                           + cslm.pollFirstEntry());
  
        // remove the last mapping and print it
        System.out.println("pollLastEntry: "
                           + cslm.pollLastEntry());
            
          // Print final map
          System.out.println("map contents: " + cslm);
    }
}

After remove(): {1=1, 2=2, 3=3, 4=4, 6=6}
pollFirstEntry: 1=1
pollLastEntry: 6=6
map contents: {2=2, 3=3, 4=4}

 3. Iterando

Podemos usar la interfaz Iterator para atravesar cualquier estructura del marco de colección. Dado que los iteradores trabajan 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 ConcurrentSkipListMap.

// Java Program to demonstrate iterating
// over ConcurrentSkipListMap
  
import java.util.concurrent.*;
import java.util.*;
  
class IteratingExample {
    public static void main(String[] args)
    {
        // create an instance of ConcurrentSkipListMap
        ConcurrentSkipListMap<Integer, Integer> cslm
            = new ConcurrentSkipListMap<>();
  
        // Add mappings using put method
        for (int i = 0; i < 6; i++) {
            cslm.put(i, i);
        }
  
        // Create an Iterator over the
        // ConcurrentSkipListMap
        Iterator<ConcurrentSkipListMap
                     .Entry<Integer, Integer> > itr
            = cslm.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()) {
            ConcurrentSkipListMap
                .Entry<Integer, Integer> entry
                = itr.next();
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }
    }
}

Key = 0, Value = 0
Key = 1, Value = 1
Key = 2, Value = 2
Key = 3, Value = 3
Key = 4, Value = 4
Key = 5, Value = 5

Métodos de ConcurrentSkipListMap

Métodos declarados en la clase java.util.AbstractMap

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

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

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

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

Referencia: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentSkipListMap.html