Interface ConcurrentNavigableMap

Uma interface java.util.concurrent.ConcurrentNavigableMap é uma subinterface da interface ConcurrentMap e oferece suporte a operações NavigableMap, e recursivamente para seus submapas navegáveis ​​e correspondências aproximadas.

Métodos ConcurrentMap

Sr. Não. Método e Descrição
1

NavigableSet<K> descendingKeySet()

Retorna uma visualização NavigableSet de ordem reversa das chaves contidas neste mapa.
2

ConcurrentNavigableMap<K,V> descendingMap()

Retorna uma visualização de ordem reversa dos mapeamentos contidos neste mapa.
3

ConcurrentNavigableMap<K,V> headMap(K toKey)

Retorna uma visualização da parte deste mapa cujas chaves são estritamente menores que toKey.
4

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

Retorna uma visualização da parte deste mapa cujas chaves são menores que (ou iguais a, se inclusivo for verdadeiro) toKey.
5

NavigableSet<K> keySet()

Retorna uma visualização NavigableSet das chaves contidas neste mapa.
6

NavigableSet<K> navigableKeySet()

Retorna uma visualização NavigableSet das chaves contidas neste mapa.
7

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

Retorna uma visualização da parte deste mapa cujas chaves variam de chave a chave chave.
8

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

Retorna uma visualização da parte deste mapa cujas chaves variam de fromKey, inclusive, a toKey, exclusivo.
9

ConcurrentNavigableMap<K,V> tailMap(K fromKey)

Retorna uma visualização da parte deste mapa cujas chaves são maiores ou iguais a fromKey.
10

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

Retorna uma visualização da parte deste mapa cujas chaves são maiores que (ou iguais a, se inclusivo for verdadeiro) fromKey.

Exemplo

O programa TestThread a seguir mostra o 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"));
   }  
}

Isso produzirá o seguinte resultado.

Resultado

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}