Interface ConcurrentNavigableMap

Une interface java.util.concurrent.ConcurrentNavigableMap est une sous-interface de l'interface ConcurrentMap et prend en charge les opérations NavigableMap, et de manière récursive pour ses sous-cartes navigables et les correspondances approximatives.

Méthodes ConcurrentMap

N ° Sr. Méthode et description
1

NavigableSet<K> descendingKeySet()

Renvoie une vue NavigableSet en ordre inverse des clés contenues dans cette carte.
2

ConcurrentNavigableMap<K,V> descendingMap()

Renvoie une vue en ordre inverse des mappages contenus dans cette carte.
3

ConcurrentNavigableMap<K,V> headMap(K toKey)

Renvoie une vue de la partie de cette carte dont les clés sont strictement inférieures à toKey.
4

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

Renvoie une vue de la partie de cette carte dont les clés sont inférieures (ou égales à, si inclusive est vraie) toKey.
5

NavigableSet<K> keySet()

Renvoie une vue NavigableSet des clés contenues dans cette carte.
6

NavigableSet<K> navigableKeySet()

Renvoie une vue NavigableSet des clés contenues dans cette carte.
sept

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

Renvoie une vue de la partie de cette carte dont les clés vont de fromKey à toKey.
8

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

Renvoie une vue de la partie de cette carte dont les clés vont de fromKey, inclus, à toKey, exclusif.
9

ConcurrentNavigableMap<K,V> tailMap(K fromKey)

Renvoie une vue de la partie de cette carte dont les clés sont supérieures ou égales à fromKey.
dix

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

Renvoie une vue de la partie de cette carte dont les clés sont supérieures (ou égales à, si inclusive est vraie) fromKey.

Exemple

Le programme TestThread suivant montre l'utilisation 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"));
   }  
}

Cela produira le résultat suivant.

Production

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}