La API ConcurrentSkipListMap se basa en la implementación de ConcurrentNavigableMap. Este mapa se ordena según el orden natural de sus claves o por un comparador proporcionado en el mapa durante el tiempo de creación. Esta clase implementa una variante concurrente de SkipLists que hace que su costo de tiempo promedio esperado sea log(n) para las operaciones containsKey, get, put, remove y sus variantes.
Esta clase y sus vistas e iteradores implementan todos los métodos opcionales de las interfaces Map e Iterator. Como la mayoría de las otras colecciones concurrentes, esta API no permite el uso de claves o valores nulos . Es miembro de Java Collections Framework.
Todas las interfaces implementadas:
Serializable, Cloneable, ConcurrentMap<K,V>, ConcurrentNavigableMap<K,V>, Map<K,V>, NavigableMap<K,V>, SortedMap<K,V>
Sintaxis:
public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V> implements ConcurrentNavigableMap<K,V>, Cloneable, Serializable
Constructores:
- ConcurrentSkipListMap() : crea un nuevo mapa vacío, clasificado según el orden natural de las claves.
- ConcurrentSkipListMap(Comparator<? super K> c) – Crea un nuevo mapa vacío ordenado según el comparador dado.
- ConcurrentSkipListMap(Map<? extends K,? extends V> mp) : crea un nuevo mapa con el mismo mapeo que el mapa dado, ordenado de acuerdo con el orden natural de las claves.
- ConcurrentSkipListMap(SortedMap<K,? extends V> mp): crea un nuevo mapa con las mismas asignaciones que el mapa dado y ordenado de acuerdo con el mapa ordenado dado.
Métodos:
| Método | Descripción |
|---|---|
| entrada de techo (tecla K) | Este método devuelve un par clave-valor asociado con la clave mínima, mayor o igual que la clave especificada, de lo contrario, nulo. |
| tecla de techo (tecla K) | Este método devuelve la clave mínima mayor o igual que la clave especificada; de lo contrario, es nula. |
| clear() | Este método elimina todos los pares clave-valor del mapa |
| clon() | Este método devuelve una copia de la instancia ConcurrentSkipListMap. |
| comparador() | Este método devuelve el comparador utilizado para ordenar las claves en el mapa; de lo contrario, es nulo si utiliza el orden natural de las claves. |
| contiene clave (clave de objeto) | Este método devuelve verdadero si el mapa contiene el par clave-valor para la clave dada. |
| contieneValor(Valor del objeto) | Este método devuelve verdadero si el mapa asigna una o más claves para el valor especificado. |
| descendingKeySet() | Este método devuelve una vista NavigableSet en orden inverso de las claves del mapa |
| mapadescendente() | Este método devuelve la vista en orden inverso de los pares clave-valor contenidos en el mapa. |
| conjuntoentrada() | Este método devuelve una vista establecida de los pares clave-valor contenidos en el mapa. |
| es igual a (Objeto o) | Este método compara el objeto dado con el mapa para la igualdad. |
| Primera entrada() | Este método devuelve un par clave-valor asociado con la clave mínima del mapa. |
| primeraClave() | Este método devuelve la primera clave (más baja) en el mapa |
| entrada de piso (tecla K) | Este método devuelve una asignación de clave-valor asociada con la clave más grande menor o igual que la clave dada o nula de otro modo |
| obtener (clave de objeto) | Este método devuelve el valor al que se asigna la clave especificada o, de lo contrario, es nulo |
| esta vacio() | Este método devuelve verdadero si el mapa no contiene ningún par clave-valor en el mapa |
| juego de llaves() | Este método devuelve una vista NavigableSet de las claves contenidas en este mapa. |
| última entrada() | Este método devuelve un par clave-valor asociado con la mayor clave en el mapa o, de lo contrario, nulo si el mapa está vacío. |
| última clave() | Este método devuelve la última clave (más alta) actualmente en el mapa. |
| headMap (K a clave) | Este método devuelve una vista de la parte del mapa cuyas claves son menores que toKey. |
| tecla inferior (tecla K) | Este método devuelve la clave mayor estrictamente menor que la clave dada, o nula si no existe tal clave. |
| Talla() | Este método devuelve el número de pares clave-valor en el mapa |
| tailMap(K fromKey) | Este método devuelve una vista de la parte del mapa cuyas claves son mayores o iguales que fromKey. |
| valores() | Este método devuelve una vista de colección de los valores en el mapa |
| eliminar (tecla de objeto) | Este método elimina la asignación de la clave especificada del mapa. |
| poner (tecla K, valor V) | Este método asocia el valor dado con la clave dada en el mapa. |
| reemplazar (tecla K, valor V) | Este método reemplaza el valor de la clave dada con el valor especificado si se asigna con algún otro valor. |
Java
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableSet;
import java.util.Set;
import java.util.SortedMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
public class ConcurrentSkipList<K, V> {
private ConcurrentSkipListMap<K, V> cmp;
// Creates a new empty map sorted according to the
// natural ordering of the keys
public ConcurrentSkipList()
{
cmp = new ConcurrentSkipListMap<K, V>();
}
// Creates a new empty map sorted according to the given
// comparator
public ConcurrentSkipList(Comparator<? super K> comp)
{
cmp = new ConcurrentSkipListMap<K, V>(comp);
}
// Creates a new map with the same key-value pairs as
// the specified map and sorted according to the natural
// ordering of the keys.
public ConcurrentSkipList(
Map<? extends K, ? extends V> mp)
{
cmp = new ConcurrentSkipListMap<K, V>(mp);
}
// Creates a new map containing the same key-value pairs
// and same ordering as the specified map.
public ConcurrentSkipList(SortedMap<K, ? extends V> mp)
{
cmp = new ConcurrentSkipListMap<K, V>(mp);
}
// Returns a mapping associated with the least key
// greater than or equal to the specified key or
// otherwise null
public Map.Entry<K, V> ceilingEntry(K k)
{
return cmp.ceilingEntry(k);
}
// Returns the least key greater than or equal to the
// specified key or otherwise null
public K ceilingKey(K k) { return cmp.ceilingKey(k); }
// Removes all the key-value pairs of the map
public void clear() { cmp.clear(); }
// Returns a copy of the ConcurrentSkipListMap
public ConcurrentSkipListMap<K, V> clone()
{
return cmp.clone();
}
// Returns the comparator used for ordering the keys in
// the map
public Comparator<? super K> comparator()
{
return cmp.comparator();
}
// Returns true if the map contains the specified key.
public boolean containsKey(Object k)
{
return cmp.containsKey(k);
}
// Returns true if the map contains one or more keys
// mapped to the given value
public boolean containsValue(Object v)
{
return cmp.containsValue(v);
}
// Returns a reverse order NavigableSet view of the keys
// in the map
public NavigableSet<K> descendingKeySet()
{
return cmp.descendingKeySet();
}
// Returns a reverse order view of the key-value pairs
// in the map.
public ConcurrentNavigableMap<K, V> descendingMap()
{
return cmp.descendingMap();
}
// Returns a Set view of the key-value pairs in the map
public Set<Map.Entry<K, V> > entrySet()
{
return cmp.entrySet();
}
// Returns the mapping that is associated with the least
// key in the map or otherwise null
public Map.Entry<K, V> firstEntry()
{
return cmp.firstEntry();
}
// Returns the first (lowest) key in the map.
public K firstKey() { return cmp.firstKey(); }
// Returns the greatest key less than or equal to the
// specified key or otherwise null
public K floorKey(K k) { return cmp.floorKey(k); }
// Returns the value to which the given key is mapped
public V get(Object k) { return cmp.get(k); }
// Returns a portion of the map whose keys are strictly
// less than k
public ConcurrentNavigableMap<K, V> headMap(K k)
{
return cmp.headMap(k);
}
// Returns a portion of the map whose keys are strictly
// less than or equal to k
public ConcurrentNavigableMap<K, V> headMap(K k,
boolean in)
{
return cmp.headMap(k, in);
}
// Returns a mapping that is associated with the least
// key strictly greater than the specified key or
// otherwise null
public Map.Entry<K, V> higherEntry(K k)
{
return cmp.higherEntry(k);
}
// Returns the least key strictly greater than the given
// key, or otherwise null.
public K higherKey(K k) { return cmp.higherKey(k); }
// Returs the set view of the keys in the map
public Set<K> keySet() { return cmp.keySet(); }
// Returns a mapping associated with the greatest key in
// the map, or otherwise null.
public Map.Entry<K, V> lastEntry()
{
return cmp.lastEntry();
}
// Returns the last(highest) key in the map.
public K lastKey() { return cmp.lastKey(); }
// Returns a mapping that is associated with the
// greatest key strictly less than the specified key or
// otherwise null
public Map.Entry<K, V> lowerEntry(K k)
{
return cmp.lowerEntry(k);
}
// Returns the greatest key strictly less than the given
// key or otherwise null
public K lowerKey(K k) { return cmp.lowerKey(k); }
// Returns a NavigableSet view of the keys in the map.
public NavigableSet<K> navigableKeySet()
{
return cmp.navigableKeySet();
}
// Removes and returns a mapping associated with the
// least key in the map, or otherwise null
public Map.Entry<K, V> pollFirstEntry()
{
return cmp.pollFirstEntry();
}
// Removes and returns a mapping associated with the
// greatest key
// in the map, or otherwise null
public Map.Entry<K, V> pollLastEntry()
{
return cmp.pollLastEntry();
}
// Maps the given value to the given key in the map
public V put(K k, V v) { return cmp.put(k, v); }
// Copies all the key-value pairs of the given map to
// the ConcurrentSkipListMap
public void putAll(Map<? extends K, ? extends V> mp)
{
cmp.putAll(mp);
}
// Removes the mapping of the given key from the map
public V remove(Object k) { return cmp.remove(k); }
// Replaces the given key with the given value if the
// key is already mapped
public V replace(K k, V v) { return cmp.replace(k, v); }
// Replaces the given key with the given value if the
// key is already mapped
public boolean replace(K k, V oValue, V nValue)
{
return cmp.replace(k, oValue, nValue);
}
// Returns the number of mapping in the map
public int size() { return cmp.size(); }
// Return a portion of the map whose keys are from k1 to
// k2
public ConcurrentNavigableMap<K, V>
subMap(K k1, boolean f, K k2, boolean t)
{
return cmp.subMap(k1, f, k2, t);
}
// Returns a portion of the map whose keys are from
// k1(inclusive) to k2(exclusive)
public ConcurrentNavigableMap<K, V> subMap(K k1, K k2)
{
return cmp.subMap(k1, k2);
}
// Returns a Collection view of the values of the map
public Collection<V> values() { return cmp.values(); }
public static void main(String[] arg)
{
ConcurrentSkipList<Integer, String> cmp
= new ConcurrentSkipList<Integer, String>();
cmp.put(1, "Sahil");
cmp.put(2, "Kahish");
cmp.put(3, "Tarun");
cmp.put(4, "Karan");
Map<Integer, String> mp
= new HashMap<Integer, String>();
mp.put(5, "Shweta");
mp.put(6, "Aditya");
cmp.putAll(mp);
System.out.println("The key set of the map is ");
Set<Integer> kSet = cmp.keySet();
Iterator<Integer> i = kSet.iterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
System.out.println();
System.out.println("The values of the Map is ");
Collection<String> values = cmp.values();
Iterator<String> it = values.iterator();
it = values.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");
}
System.out.println();
System.out.println(
"Poll first entry of the ConcurrentSkipListMap ");
Map.Entry<Integer, String> pfe
= cmp.pollFirstEntry();
System.out.println("Key = " + pfe.getKey()
+ " Value = " + pfe.getValue());
System.out.println(
"Poll last entry of the ConcurrentSkipListMap ");
Map.Entry<Integer, String> ple
= cmp.pollLastEntry();
System.out.println("key = " + ple.getKey()
+ " value = " + ple.getValue());
System.out.println("The entry set of the map is ");
Iterator<Entry<Integer, String> > itr;
Set<Entry<Integer, String> > eSet = cmp.entrySet();
itr = eSet.iterator();
while (itr.hasNext()) {
System.out.println(itr.next() + " ");
}
System.out.println(
"The concurrentSkipListMap contains Key 4 :"
+ cmp.containsKey(4));
System.out.println(
"The concurrentSkipListMap contains Value 9 :"
+ cmp.containsValue(9));
System.out.println(
"The size of the concurrentSkipListMap is "
+ cmp.size());
cmp.clear();
}
}
Producción:
The key set of the map is 1 2 3 4 5 6 The values of the concurrentSkipListMap is Sahil Kashish Tarun Karan Shweta Aditya Poll first entry of the ConcurrentSkipListMap key = 1 value = Sahil Poll last entry of the ConcurrentSkipListMap key = 6 value = Aditya The entry set of the Map is 2=Kashish 3=Tarun 4=Karan 5=Shweta The concurrentSkipListMap contains Key 4 :true The concurrentSkipListMap contains Value 9 :false The size of the concurrentSkipListMap is 6
Publicación traducida automáticamente
Artículo escrito por namitachaudhary60 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA