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.

  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.
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if the specified key is null

 

 
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if the specified key is null

Removes all of the mappings from this map.

  Returns a shallow copy of this ConcurrentSkipListMap instance.

  Returns a shallow copy of this ConcurrentSkipListMap
instance. (The keys and values themselves are not cloned.)
Returns: a shallow copy of this map

  Compares using comparator or natural ordering.

  Compares using comparator or natural ordering. Used when the
ComparableUsingComparator approach doesn't apply.

  Returns true if this map contains a mapping for the specified key.

  Returns true if this map contains a mapping for the specified
key.
Returns: true if this map contains a mapping for the specified key
Parameters:
- key - key whose presence in this map is to be tested
Throws:
- ClassCastException - if the specified key cannot be compared with the keys currently in the map
- NullPointerException - if the specified key is null

  Returns true if this map maps one or more keys to the specified value.

  Returns true if this map maps one or more keys to the
specified value. This operation requires time linear in the
map size.
Returns: true if a mapping to value exists; false otherwise
Parameters:
- value - value whose presence in this map is to be tested
Throws:
- NullPointerException - if the specified value is null

  Main deletion method.

  Main deletion method. Locates node, nulls value, appends a
deletion marker, unlinks predecessor, removes associated index
nodes, and possibly reduces head index level.

Index nodes are cleared out simply by calling findPredecessor.
which unlinks indexes to deleted nodes found along path to key,
which will include the indexes to this node. This is done
unconditionally. We can't check beforehand whether there are
index nodes because it might be the case that some or all
indexes hadn't been inserted yet for this node during initial
search for it, and we'd like to ensure lack of garbage
retention, so must call to be sure.
Returns: the node, or null if not found
Parameters:
- okey - the key
- value - if non-null, the value that must be associated with key

  Removes first entry; returns its snapshot.

  Removes first entry; returns its snapshot.
Returns: null if empty, else snapshot of first entry

  Removes last entry; returns its snapshot.

  Removes last entry; returns its snapshot.
Specialized variant of doRemove.
Returns: null if empty, else snapshot of last entry

  Returns a Set view of the mappings contained in this map.

  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 ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.

The Map.Entry elements returned by iterator.next() do not support the setValue operation.
Returns: a set view of the mappings contained in this map, sorted in ascending key order

  Compares the specified object with this map for equality.

  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.
Returns: true if the specified object is equal to this map
Parameters:
- o - object to be compared for equality with this map

  Specialized variant of findNode to get first valid node.

  Specialized variant of findNode to get first valid node.
Returns: first node or null if empty

  Specialized version of find to get last valid node.

  Specialized version of find to get last valid node.
Returns: last node or null if empty

  Utility for ceiling, floor, lower, higher methods.

  Utility for ceiling, floor, lower, higher methods.
Returns: nearest node fitting relation, or null if no such
Parameters:
- kkey - the key
- rel - the relation -- OR'ed combination of EQ, LT, GT

  Returns a key-value mapping associated with the least key in this map, or null if the map is empty.

  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.

 

 
Throws:
- NoSuchElementException - {@inheritDoc}

  Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.

  Returns a key-value mapping associated with the greatest key
less than or equal to the given key, or null if there
is no such key. The returned entry does not support
the Entry.setValue method.
Parameters:
- key - the key
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if the specified key is null

 

 
Parameters:
- key - the key
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if the specified key is null

  Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.

  Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.

More formally, if this map contains a mapping from a key k to a value v such that key compares equal to k according to the map's ordering, then this method returns v; otherwise it returns null. (There can be at most one such mapping.)
Throws:
- ClassCastException - if the specified key cannot be compared with the keys currently in the map
- NullPointerException - if the specified key is null

  Returns SimpleImmutableEntry for results of findNear.

  Returns SimpleImmutableEntry for results of findNear.
Returns: Entry fitting relation, or null if no such
Parameters:
- key - the key
- rel - the relation -- OR'ed combination of EQ, LT, GT

 

 
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if {@code toKey} is null
- IllegalArgumentException - {@inheritDoc}

 

 
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if {@code toKey} is null
- IllegalArgumentException - {@inheritDoc}

  Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.

  Returns a key-value mapping associated with the least key
strictly greater than the given key, or null if there
is no such key. The returned entry does not support
the Entry.setValue method.
Parameters:
- key - the key
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if the specified key is null

 

 
Parameters:
- key - the key
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if the specified key is null

  Returns true if given key greater than or equal to least and strictly less than fence, bypassing either test if least or fence are null.

  Returns true if given key greater than or equal to least and
strictly less than fence, bypassing either test if least or
fence are null. Needed mainly in submap operations.

  Initializes or resets state.

  Initializes or resets state. Needed by constructors, clone,
clear, readObject. and ConcurrentSkipListSet.clone.
(Note that comparator must be separately initialized.)

  Returns true if given key greater than or equal to least and less or equal to fence.

  Returns true if given key greater than or equal to least and less
or equal to fence. Needed mainly in submap operations.

  Returns true if this map contains no key-value mappings.

  Returns true if this map contains no key-value mappings.
Returns: true if this map contains no key-value mappings

  Returns a NavigableSet view of the keys contained in this map.

  Returns a NavigableSet view of the keys contained in this map. The set's iterator returns the keys in ascending 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 ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.

This method is equivalent to method navigableKeySet.
Returns: a navigable set view of the keys in this map

  Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.

  Returns a key-value mapping associated with the greatest
key in this map, or null if the map is empty.
The returned entry does not support
the Entry.setValue method.

 

 
Throws:
- NoSuchElementException - {@inheritDoc}

  Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.

  Returns a key-value mapping associated with the greatest key
strictly less than the given key, or null if there is
no such key. The returned entry does not support the
Entry.setValue method.
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if the specified key is null

 

 
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if the specified key is null

  Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty.

  Removes and 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.

  Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.

  Removes and returns a key-value mapping associated with
the greatest key in this map, or null if the map is empty.
The returned entry does not support
the Entry.setValue method.

  Associates the specified value with the specified key in this map.

  Associates the specified value with the specified key in this map.
If the map previously contained a mapping for the key, the old
value is replaced.
Returns: the previous value associated with the specified key, or null if there was no mapping for the key
Parameters:
- key - key with which the specified value is to be associated
- value - value to be associated with the specified key
Throws:
- ClassCastException - if the specified key cannot be compared with the keys currently in the map
- NullPointerException - if the specified key or value is null

  If the specified key is not already associated with a value, associate it with the given value.

  If the specified key is not already associated
with a value, associate it with the given value.
This is equivalent to

   if (!map.containsKey(key))
       return map.put(key, value);
   else
       return map.get(key);

except that the action is performed atomically.
Returns: the previous value associated with the specified key, or null if there was no mapping for the key
Throws:
- ClassCastException - if the specified key cannot be compared with the keys currently in the map
- NullPointerException - if the specified key or value is null

  Removes the mapping for the specified key from this map if present.

  Removes the mapping for the specified key from this map if present.
Returns: the previous value associated with the specified key, or null if there was no mapping for the key
Parameters:
- key - key for which mapping should be removed
Throws:
- ClassCastException - if the specified key cannot be compared with the keys currently in the map
- NullPointerException - if the specified key is null

  Removes the entry for a key only if currently mapped to a given value.

  Removes the entry for a key only if currently mapped to a given value.
This is equivalent to

   if (map.containsKey(key) && map.get(key).equals(value)) {
       map.remove(key);
       return true;
   } else return false;

except that the action is performed atomically.
Throws:
- ClassCastException - if the specified key cannot be compared with the keys currently in the map
- NullPointerException - if the specified key is null

  Replaces the entry for a key only if currently mapped to some value.

  Replaces the entry for a key only if currently mapped to some value.
This is equivalent to

   if (map.containsKey(key)) {
       return map.put(key, value);
   } else return null;

except that the action is performed atomically.
Returns: the previous value associated with the specified key, or null if there was no mapping for the key
Throws:
- ClassCastException - if the specified key cannot be compared with the keys currently in the map
- NullPointerException - if the specified key or value is null

  Replaces the entry for a key only if currently mapped to a given value.

  Replaces the entry for a key only if currently mapped to a given value.
This is equivalent to

   if (map.containsKey(key) && map.get(key).equals(oldValue)) {
       map.put(key, newValue);
       return true;
   } else return false;

except that the action is performed atomically.
Throws:
- ClassCastException - if the specified key cannot be compared with the keys currently in the map
- NullPointerException - if any of the arguments are null

  Returns the number of key-value mappings in this map.

  Returns the number of key-value mappings in this map. If this map contains more than Integer.MAX_VALUE elements, it returns Integer.MAX_VALUE.

Beware that, unlike in most collections, this method is NOT a constant-time operation. Because of the asynchronous nature of these maps, determining the current number of elements requires traversing them all to count them. Additionally, it is possible for the size to change during execution of this method, in which case the returned result will be inaccurate. Thus, this method is typically not very useful in concurrent applications.
Returns: the number of elements in this map

 

 
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if {@code fromKey} or {@code toKey} is null
- IllegalArgumentException - {@inheritDoc}

 

 
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if {@code fromKey} or {@code toKey} is null
- IllegalArgumentException - {@inheritDoc}

 

 
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if {@code fromKey} is null
- IllegalArgumentException - {@inheritDoc}

 

 
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - if {@code fromKey} is null
- IllegalArgumentException - {@inheritDoc}

  Returns a Collection view of the values contained in this map.

  Returns a Collection view of the values contained in this map. The collection's iterator returns the values in ascending order of the corresponding keys. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Collection.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 ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.