Interfaz ConcurrentNavigableMap

Una interfaz java.util.concurrent.ConcurrentNavigableMap es una subinterfaz de la interfaz ConcurrentMap y admite operaciones NavigableMap, y de forma recursiva para sus submapas navegables y coincidencias aproximadas.

Métodos ConcurrentMap

No Señor. Método y descripción
1

NavigableSet<K> descendingKeySet()

Devuelve una vista NavigableSet en orden inverso de las claves contenidas en este mapa.
2

ConcurrentNavigableMap<K,V> descendingMap()

Devuelve una vista en orden inverso de las asignaciones contenidas en este mapa.
3

ConcurrentNavigableMap<K,V> headMap(K toKey)

Devuelve una vista de la parte de este mapa cuyas claves son estrictamente menores que toKey.
4

ConcurrentNavigableMap<K,V> headMap(K toKey, boolean inclusive)

Devuelve una vista de la parte de este mapa cuyas claves son menores (o iguales a, si inclusivo es verdadero) toKey.
5

NavigableSet<K> keySet()

Devuelve una vista NavigableSet de las claves contenidas en este mapa.
6

NavigableSet<K> navigableKeySet()

Devuelve una vista NavigableSet de las claves contenidas en este mapa.
7

ConcurrentNavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)

Devuelve una vista de la parte de este mapa cuyas claves van de fromKey a toKey.
8

ConcurrentNavigableMap<K,V> subMap(K fromKey, K toKey)

Devuelve una vista de la parte de este mapa cuyas claves van de fromKey, inclusive, a toKey, exclusivo.
9

ConcurrentNavigableMap<K,V> tailMap(K fromKey)

Devuelve una vista de la parte de este mapa cuyas claves son mayores o iguales que fromKey.
10

ConcurrentNavigableMap<K,V> tailMap(K fromKey, boolean inclusive)

Devuelve una vista de la parte de este mapa cuyas claves son mayores que (o iguales a, si inclusivo es verdadero) fromKey.

Ejemplo

El siguiente programa TestThread muestra el uso de ConcurrentNavigableMap.

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

public class TestThread {

   public static void main(final String[] arguments) {
      ConcurrentNavigableMap<String,String> map =
         new ConcurrentSkipListMap<String, String>();

      map.put("1", "One");
      map.put("2", "Two");
      map.put("3", "Three");
      map.put("5", "Five");
      map.put("6", "Six");

      System.out.println("Initial ConcurrentHashMap: "+map);
      System.out.println("HeadMap(\"2\") of ConcurrentHashMap: "+map.headMap("2"));
      System.out.println("TailMap(\"2\") of ConcurrentHashMap: "+map.tailMap("2"));
      System.out.println(
         "SubMap(\"2\", \"4\") of ConcurrentHashMap: "+map.subMap("2","4"));
   }  
}

Esto producirá el siguiente resultado.

Salida

Initial ConcurrentHashMap: {1 = One, 2 = Two, 3 = Three, 5 = Five, 6 = Six}
HeadMap("2") of ConcurrentHashMap: {1 = One}
TailMap("2") of ConcurrentHashMap: {2 = Two, 3 = Three, 5 = Five, 6 = Six}
SubMap("2", "4") of ConcurrentHashMap: {2 = Two, 3 = Three}