K
- the type of keys maintained by this mapV
- the type of mapped valuespublic class ConcurrentLinkedHashMapPro<K,V> extends AbstractMapPro<K,V> implements ConcurrentMap<K,V>, Serializable
Concurrent hash map and linked list implementation of the ConcurrentMap interface, with predictable iteration order. This implementation differs from ConcurrentHashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order). Note that insertion order is not affected if a key is re-inserted into the map. (A key k is reinserted into a map m if m.put(k, v) is invoked when m.containsKey(k) would return true immediately prior to the invocation.)
This implementation spares its clients from the unspecified, generally
chaotic ordering provided by ConcurrentHashMap
(and Hashtable
),
without incurring the increased cost associated with TreeMap
. It
can be used to produce a copy of a map that has the same order as the
original, regardless of the original map's implementation:
void foo(Map m) { Map copy = new ConcurrentLinkedHashMap(m); ... }This technique is particularly useful if a module takes a map on input, copies it, and later returns results whose order is determined by that of the copy. (Clients generally appreciate having things returned in the same order they were presented.)
A special constructor
is provided to create a concurrent linked hash map whose order of iteration
is the order designated by the relevant eviction policy class. Invoking the
put or get method results in an access to the corresponding
entry (assuming it exists after the invocation completes). The putAll
method generates one entry access for each mapping in the specified map, in the
order that key-value mappings are provided by the specified map's entry set iterator.
No other methods generate entry accesses. In particular, operations on
collection-views do not affect the order of iteration of the backing
map.
The removeEldestEntry(Map.Entry)
method may be overridden to
impose a policy for removing stale mappings automatically when new mappings
are added to the map.
Performance is likely to be just slightly below that of ComcurrentHashMap,
due to the added expense of maintaining the linked list, with one exception:
Iteration over the collection-views of a ConcurrentLinkedHashMap requires
time proportional to the size of the map, regardless of its capacity.
Iteration over a ConcurrentHashMap is likely to be more expensive,
requiring time proportional to its capacity.
Modifier and Type | Class and Description |
---|---|
static interface |
ConcurrentLinkedHashMapPro.Entry<K,V> |
AbstractMapPro.SimpleEntry<K,V>, AbstractMapPro.SimpleImmutableEntry<K,V>
Constructor and Description |
---|
ConcurrentLinkedHashMapPro()
Creates a new, empty map with a default initial capacity (16),
load factor (0.75) and concurrencyLevel (16).
|
ConcurrentLinkedHashMapPro(int initialCapacity)
Creates a new, empty map with the specified initial capacity,
and with default load factor (0.75) and concurrencyLevel (16).
|
ConcurrentLinkedHashMapPro(int initialCapacity,
float loadFactor)
Creates a new, empty map with the specified initial capacity
and load factor and with the default concurrencyLevel (16).
|
ConcurrentLinkedHashMapPro(int initialCapacity,
float loadFactor,
int concurrencyLevel,
int maxSize,
EvictionPolicy evictionPolicy)
Creates a new, empty map with the specified initial
capacity, load factor, concurrency level, max size and eviction policy.
|
ConcurrentLinkedHashMapPro(Map<? extends K,? extends V> m)
Creates a new map with the same mappings as the given map.
|
Modifier and Type | Method and Description |
---|---|
void |
clear()
Removes all of the mappings from this map.
|
boolean |
contains(Object value)
Legacy method testing if some key maps into the specified value
in this table.
|
boolean |
containsKey(Object key)
Tests if the specified object is a key in this table.
|
boolean |
containsValue(Object value)
Returns true if this map maps one or more keys to the
specified value.
|
Enumeration<V> |
elements()
Returns an enumeration of the values in this table.
|
Set<Map.Entry<K,V>> |
entrySet()
Returns a
Set view of the mappings contained in this map. |
V |
g(K key) |
V |
g(K key,
V defaultValue) |
V |
get(Object key)
Returns the value to which the specified key is mapped,
or
null if this map contains no mapping for the key. |
boolean |
isEmpty()
Returns true if this map contains no key-value mappings.
|
Enumeration<K> |
keys()
Returns an enumeration of the keys in this table.
|
Set<K> |
keySet()
Returns a
Set view of the keys contained in this map. |
V |
put(K key,
V value)
Maps the specified key to the specified value in this table.
|
void |
putAll(Map<? extends K,? extends V> m)
Copies all of the mappings from the specified map to this one.
|
V |
putIfAbsent(K key,
V value) |
V |
r(K key) |
V |
r(K key,
V defaultValue) |
V |
remove(Object key)
Removes the key (and its corresponding value) from this map.
|
boolean |
remove(Object key,
Object value) |
V |
replace(K key,
V value) |
boolean |
replace(K key,
V oldValue,
V newValue) |
int |
size()
Returns the number of key-value mappings in this map.
|
Collection<V> |
values()
Returns a
Collection view of the values contained in this map. |
equals, invalidKey, readExternal, toString, writeExternal
public ConcurrentLinkedHashMapPro(int initialCapacity, float loadFactor, int concurrencyLevel, int maxSize, EvictionPolicy evictionPolicy)
initialCapacity
- the initial capacity. The implementation
performs internal sizing to accommodate this many elements.loadFactor
- the load factor threshold, used to control resizing.
Resizing may be performed when the average number of elements per
bin exceeds this threshold.concurrencyLevel
- the estimated number of concurrently
updating threads. The implementation performs internal sizing
to try to accommodate this many threads.maxSize
- the maximum number of name/value pairs this map
will hold.evictionPolicy
- the eviction policy to be usedIllegalArgumentException
- if the initial capacity is
negative or the load factor or concurrencyLevel are
nonpositive.public ConcurrentLinkedHashMapPro(int initialCapacity, float loadFactor)
initialCapacity
- The implementation performs internal
sizing to accommodate this many elements.loadFactor
- the load factor threshold, used to control resizing.
Resizing may be performed when the average number of elements per
bin exceeds this threshold.IllegalArgumentException
- if the initial capacity of
elements is negative or the load factor is nonpositivepublic ConcurrentLinkedHashMapPro(int initialCapacity)
initialCapacity
- the initial capacity. The implementation
performs internal sizing to accommodate this many elements.IllegalArgumentException
- if the initial capacity of
elements is negative.public ConcurrentLinkedHashMapPro()
public ConcurrentLinkedHashMapPro(Map<? extends K,? extends V> m)
m
- the mappublic boolean isEmpty()
public int size()
public V get(Object key)
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.equals(k)
,
then this method returns v
; otherwise it returns
null
. (There can be at most one such mapping.)
get
in interface Map<K,V>
get
in class AbstractMapPro<K,V>
NullPointerException
- if the specified key is nullpublic V g(K key) throws PageException
g
in interface MapPro<K,V>
PageException
public boolean containsKey(Object key)
containsKey
in interface Map<K,V>
containsKey
in class AbstractMapPro<K,V>
key
- possible keyNullPointerException
- if the specified key is nullpublic boolean containsValue(Object value)
containsValue
in interface Map<K,V>
containsValue
in class AbstractMapPro<K,V>
value
- value whose presence in this map is to be testedNullPointerException
- if the specified value is nullpublic boolean contains(Object value)
containsValue(java.lang.Object)
, and exists solely to ensure
full compatibility with class Hashtable
,
which supported this method prior to introduction of the
Java Collections framework.value
- a value to search forNullPointerException
- if the specified value is nullpublic V put(K key, V value)
The value can be retrieved by calling the get method with a key that is equal to the original key.
put
in interface Map<K,V>
put
in class AbstractMapPro<K,V>
key
- key with which the specified value is to be associatedvalue
- value to be associated with the specified keyNullPointerException
- if the specified key or value is nullpublic V putIfAbsent(K key, V value)
putIfAbsent
in interface ConcurrentMap<K,V>
NullPointerException
- if the specified key or value is nullpublic void putAll(Map<? extends K,? extends V> m)
public V remove(Object key)
remove
in interface Map<K,V>
remove
in class AbstractMapPro<K,V>
key
- the key that needs to be removedNullPointerException
- if the specified key is nullpublic V r(K key) throws PageException
r
in interface MapPro<K,V>
PageException
public boolean remove(Object key, Object value)
remove
in interface ConcurrentMap<K,V>
NullPointerException
- if the specified key is nullpublic boolean replace(K key, V oldValue, V newValue)
replace
in interface ConcurrentMap<K,V>
NullPointerException
- if any of the arguments are nullpublic V replace(K key, V value)
replace
in interface ConcurrentMap<K,V>
NullPointerException
- if the specified key or value is nullpublic void clear()
public Set<K> keySet()
Set
view of the keys contained in this map.
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 this 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.
public Collection<V> values()
Collection
view of the values contained in this map.
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 this 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.
public Set<Map.Entry<K,V>> entrySet()
Set
view of the mappings contained in this map.
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.
public Enumeration<K> keys()
keySet()
public Enumeration<V> elements()
values()
Copyright © 2015 Lucee