ConcurrentSkipListMap<K, V>
Java SE 6
| public class java.util.concurrent ConcurrentSkipListMap<K, V>
|
Java SE 6 |
ConcurrentNavigableMap implementation.
The map is sorted according to the natural
ordering of its keys, or by a Comparator provided at map
creation time, depending on which constructor is used.
This class implements a concurrent variant of SkipLists providing
expected average log(n) time cost for the
containsKey, get, put and
remove operations and their variants. Insertion, removal,
update, and access operations safely execute concurrently by
multiple threads. Iterators are weakly consistent, returning
elements reflecting the state of the map at some point at or since
the creation of the iterator. They do not throw ConcurrentModificationException, and may proceed concurrently with
other operations. Ascending key ordered views and their iterators
are faster than descending ones.
All Map.Entry pairs returned by methods in this class and its views represent snapshots of mappings at the time they were produced. They do not support the Entry.setValue method. (Note however that it is possible to change mappings in the associated map using put, putIfAbsent, or replace, depending on exactly which effect you need.)
Beware that, unlike in most collections, the size method is not a constant-time operation. Because of the asynchronous nature of these maps, determining the current number of elements requires a traversal of the elements. Additionally, the bulk operations putAll, equals, and clear are not guaranteed to be performed atomically. For example, an iterator operating concurrently with a putAll operation might view only some of the added elements.
This class and its views and iterators implement all of the
optional methods of the Map and Iterator
interfaces. Like most other concurrent collections, this class does
not permit the use of null keys or values because some
null return values cannot be reliably distinguished from the absence of
elements.
This class is a member of the Java Collections Framework.
| K | the type of keys maintained by this map |
| V | the type of mapped values |
| since | 1.6 |
| Constructors | |||||||
|---|---|---|---|---|---|---|---|
| public | ConcurrentSkipListMap() Constructs a new, empty map, sorted according to the natural ordering of the keys. | ||||||
| public | ConcurrentSkipListMap(Comparator comparator) Details
Constructs a new, empty map, sorted according to the specified
comparator.
| ||||||
| public | ConcurrentSkipListMap(Map m) Details
Constructs a new map containing the same mappings as the given map,
sorted according to the natural ordering of
the keys.
| ||||||
| public | ConcurrentSkipListMap(SortedMap m) Details
Constructs a new map containing the same mappings and using the
same ordering as the specified sorted map.
| ||||||
| Methods | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|
| public Map.Entry | ceilingEntry(Object key) Details
Returns a key-value mapping associated with the least key
greater than or equal to the given key, or null if
there is no such entry. The returned entry does not
support the Entry.setValue method.
| |||||||||
| public Object | ceilingKey(Object key) Details
| |||||||||
| public void | clear() Removes all of the mappings from this map. | |||||||||
| public ConcurrentSkipListMap | clone() Details
Returns a shallow copy of this ConcurrentSkipListMap
instance. (The keys and values themselves are not cloned.)
| |||||||||
| public Comparator | comparator() | |||||||||
| public boolean | containsKey(Object key) Details
Returns true if this map contains a mapping for the specified
key.
| |||||||||
| public boolean | containsValue(Object value) Details
Returns true if this map maps one or more keys to the
specified value. This operation requires time linear in the
map size.
| |||||||||
| public NavigableSet | descendingKeySet() | |||||||||
| public ConcurrentNavigableMap | descendingMap() | |||||||||
| public Set | entrySet() Details
Returns a Set view of the mappings contained in this map.
The set's iterator returns the entries in ascending key order.
The set is backed by the map, so changes to the map are
reflected in the set, and vice-versa. The set supports element
removal, which removes the corresponding mapping from the map,
via the Iterator.remove, Set.remove,
removeAll, retainAll and clear
operations. It does not support the add or
addAll operations.
The view's iterator is a "weakly consistent" iterator
that will never throw The Map.Entry elements returned by iterator.next() do not support the setValue operation.
| |||||||||
| public boolean | equals(Object o) Details
Compares the specified object with this map for equality.
Returns true if the given object is also a map and the
two maps represent the same mappings. More formally, two maps
m1 and m2 represent the same mappings if
m1.entrySet().equals(m2.entrySet()). This
operation may return misleading results if either map is
concurrently modified during execution of this method.
| |||||||||
| public Map.Entry | firstEntry() Returns a key-value mapping associated with the least key in this map, or null if the map is empty. The returned entry does not support the Entry.setValue method. | |||||||||
| public Object | firstKey() Details
| |||||||||
