K - the key typeV - the value type@ThreadSafe public abstract class CopyOnWriteSortedMap<K,V> extends Object implements SortedMap<K,V>
SortedMap in which all mutative
operations (the "destructive" operations described by
SortedMap put, remove and so on) are implemented by making
a fresh copy of the underlying map.
This is ordinarily too costly, but may be more efficient than
alternatives when traversal operations vastly out-number mutations, and is
useful when you cannot or don't want to synchronize traversals, yet need to
preclude interference among concurrent threads. The "snapshot" style
iterators on the collections returned by entrySet(),
keySet() and values() use a reference to the internal map
at the point that the iterator was created. This map never changes during the
lifetime of the iterator, so interference is impossible and the iterator is
guaranteed not to throw ConcurrentModificationException. The
iterators will not reflect additions, removals, or changes to the list since
the iterator was created. Removing elements via these iterators is not
supported. The mutable operations on these collections (remove, retain etc.)
may be supported if the views are live but as with the Map
interface, add and addAll are not and throw
UnsupportedOperationException.
The actual copy is performed by the abstract copy(Map) method. This
implementation of this method is responsible for the underlying
SortedMap implementation (for instance a
TreeMap) and therefore the semantics of what this map will
cope with as far as null keys and values, iteration ordering etc. Standard
j.u.c Map implementation versions are available from the
CopyOnWriteSortedMap.Builder.
Collection views of the keys, values and entries are optionally
live or stable. Live views
are modifiable will cause a copy if a modifying method is called on them.
Methods on these will reflect the current state of the collection, although
iterators will be snapshot style. If the collection views are stable they are
unmodifiable, and will be a snapshot of the state of the map at the time the
collection was asked for. Regardless of the View policy though, all Views
taken using subMap(Object, Object), headMap(Object) and
tailMap(Object) are unmodifiable.
Please note that the thread-safety guarantees are limited to
the thread-safety of the non-mutative (non-destructive) operations of the
underlying map implementation. If the underlying map implementation does not
support concurrent get(Object) calls for instance then it is
unsuitable as a candidate.
| Modifier and Type | Class and Description |
|---|---|
protected static class |
AbstractCopyOnWriteMap.CollectionView<E> |
static class |
AbstractCopyOnWriteMap.View<K,V>
Provides access to the views of the underlying key, value and entry
collections.
|
static class |
CopyOnWriteSortedMap.Builder<K,V>
Build a
CopyOnWriteSortedMap and specify all the options. |
| Modifier | Constructor and Description |
|---|---|
protected |
CopyOnWriteSortedMap(AbstractCopyOnWriteMap.View.Type viewType)
Create a new empty
CopyOnWriteMap. |
protected |
CopyOnWriteSortedMap(Map<? extends K,? extends V> map,
AbstractCopyOnWriteMap.View.Type viewType)
Create a new
CopyOnWriteMap with the
supplied Map to initialize the values. |
| Modifier and Type | Method and Description |
|---|---|
static <K,V> CopyOnWriteSortedMap.Builder<K,V> |
builder()
Get a
CopyOnWriteSortedMap.Builder for
a CopyOnWriteSortedMap instance. |
void |
clear()
Return a new copy containing no elements
|
Comparator<? super K> |
comparator() |
boolean |
containsKey(Object key) |
boolean |
containsValue(Object value) |
protected M |
copy()
Create a copy of the underlying map.
|
protected abstract <N extends Map<? extends K,? extends V>> |
copy(N map)
Copy function, implemented by sub-classes.
|
Set<Map.Entry<K,V>> |
entrySet() |
boolean |
equals(Object o) |
K |
firstKey() |
V |
get(Object key) |
protected M |
getDelegate()
Return the internal delegate map.
|
int |
hashCode() |
SortedMap<K,V> |
headMap(K toKey) |
boolean |
isEmpty() |
Set<K> |
keySet() |
K |
lastKey() |
static <K,V> CopyOnWriteSortedMap<K,V> |
newTreeMap()
Create a new
CopyOnWriteSortedMap
where the underlying map instances are TreeMap and the
sort uses the key's natural order. |
static <K,V> CopyOnWriteSortedMap<K,V> |
newTreeMap(Comparator<? super K> comparator)
Create a new
CopyOnWriteSortedMap
where the underlying map instances are TreeMap. |
static <K,V> CopyOnWriteSortedMap<K,V> |
newTreeMap(Map<? extends K,? extends V> map)
Create a new
CopyOnWriteSortedMap
where the underlying map instances are TreeMap, the sort
uses the key's natural order and the initial values are supplied. |
static <K,V> CopyOnWriteSortedMap<K,V> |
newTreeMap(Map<? extends K,? extends V> map,
Comparator<? super K> comparator)
Create a new
CopyOnWriteSortedMap
where the underlying map instances are TreeMap, the sort
uses the key's natural order and the initial values are supplied. |
V |
put(K key,
V value)
Add this key and its value to the map
|
void |
putAll(Map<? extends K,? extends V> t) |
V |
putIfAbsent(K key,
V value)
If the key is not currently contained in the map add it.
|
V |
remove(Object key) |
boolean |
remove(Object key,
Object value) |
V |
replace(K key,
V value)
Replace the value of the key if the key is present returning the value.
|
boolean |
replace(K key,
V oldValue,
V newValue)
Attempt to replace the value of the key with newValues so long as the key
is still associated with old value
|
protected void |
set(M map)
Set the contained map
|
int |
size() |
SortedMap<K,V> |
subMap(K fromKey,
K toKey) |
SortedMap<K,V> |
tailMap(K fromKey) |
String |
toString() |
Collection<V> |
values() |
clone, finalize, getClass, notify, notifyAll, wait, wait, waitclear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, equals, forEach, get, getOrDefault, hashCode, isEmpty, merge, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, sizecompute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAllprotected CopyOnWriteSortedMap(AbstractCopyOnWriteMap.View.Type viewType)
CopyOnWriteMap.viewType - a View.Type object.protected CopyOnWriteSortedMap(Map<? extends K,? extends V> map, AbstractCopyOnWriteMap.View.Type viewType)
CopyOnWriteMap with the
supplied Map to initialize the values.map - the initial map to initialize withviewType - a View.Type.public static <K,V> CopyOnWriteSortedMap.Builder<K,V> builder()
CopyOnWriteSortedMap.Builder for
a CopyOnWriteSortedMap instance.K - key typeV - value typepublic static <K,V> CopyOnWriteSortedMap<K,V> newTreeMap()
CopyOnWriteSortedMap
where the underlying map instances are TreeMap and the
sort uses the key's natural order.
This map has stable views.
CopyOnWriteSortedMap.public static <K,V> CopyOnWriteSortedMap<K,V> newTreeMap(@NotNull Map<? extends K,? extends V> map)
CopyOnWriteSortedMap
where the underlying map instances are TreeMap, the sort
uses the key's natural order and the initial values are supplied.
This map has stable views.
K - a K key type.V - a V value type.map - the map to use as the initial values.CopyOnWriteSortedMap.public static <K,V> CopyOnWriteSortedMap<K,V> newTreeMap(@NotNull Comparator<? super K> comparator)
CopyOnWriteSortedMap
where the underlying map instances are TreeMap.
This map has stable views.
K - a K key type.V - a V value type.comparator - the Comparator to use for ordering the keys. Note, should
be serializable if this map is to be serialized.CopyOnWriteSortedMap.public static <K,V> CopyOnWriteSortedMap<K,V> newTreeMap(@NotNull Map<? extends K,? extends V> map, @NotNull Comparator<? super K> comparator)
CopyOnWriteSortedMap
where the underlying map instances are TreeMap, the sort
uses the key's natural order and the initial values are supplied.
This map has stable views.
K - a K key type.V - a V value type.map - to use as the initial values.comparator - for ordering.CopyOnWriteSortedMap.protected abstract <N extends Map<? extends K,? extends V>> SortedMap<K,V> copy(N map)
N - the map to copy and return.map - the initial values of the newly created map.public Comparator<? super K> comparator()
comparator in interface SortedMap<K,V>public final void clear()
public final boolean remove(Object key, Object value)
remove in interface ConcurrentMap<K,V>remove in interface Map<K,V>public final boolean replace(K key,
V oldValue,
V newValue)
replace in interface ConcurrentMap<K,V>replace in interface Map<K,V>key - a K key to to define a new association for.oldValue - if this value is still present replace it with newValue.newValue - a V to add to the map.public final V replace(K key,
V value)
replace in interface ConcurrentMap<K,V>replace in interface Map<K,V>key - a K key.value - a V value.public final V put(K key,
V value)
public final V putIfAbsent(K key,
V value)
putIfAbsent in interface ConcurrentMap<K,V>putIfAbsent in interface Map<K,V>key - a K key.value - a V value.public final void putAll(Map<? extends K,? extends V> t)
protected M copy()
protected final void set(M map)
map - a M contained by this class.public final Collection<V> values()
public final boolean containsKey(Object key)
containsKey in interface Map<K,V>public final boolean containsValue(Object value)
containsValue in interface Map<K,V>public final boolean equals(Object o)
public final int hashCode()
protected final M getDelegate()
Copyright © 2024 Atlassian. All rights reserved.