K
- the type of keys maintained by this mapV
- the type of mapped valuespublic final class ConcurrentWeakKeyHashMap<K,V>
extends java.util.AbstractMap<K,V>
implements java.util.concurrent.ConcurrentMap<K,V>
ConcurrentMap
which is similar to ConcurrentHashMap
.Modifier and Type | Class and Description |
---|---|
(package private) class |
ConcurrentWeakKeyHashMap.EntryIterator |
(package private) class |
ConcurrentWeakKeyHashMap.EntrySet |
(package private) static class |
ConcurrentWeakKeyHashMap.HashEntry<K,V>
ConcurrentReferenceHashMap list entry.
|
(package private) class |
ConcurrentWeakKeyHashMap.HashIterator |
(package private) class |
ConcurrentWeakKeyHashMap.KeyIterator |
(package private) class |
ConcurrentWeakKeyHashMap.KeySet |
static interface |
ConcurrentWeakKeyHashMap.ReusableIterator<E> |
(package private) static class |
ConcurrentWeakKeyHashMap.Segment<K,V>
Segments are specialized versions of hash tables.
|
(package private) static class |
ConcurrentWeakKeyHashMap.SimpleEntry<K,V> |
(package private) class |
ConcurrentWeakKeyHashMap.ValueIterator |
(package private) class |
ConcurrentWeakKeyHashMap.Values |
(package private) static class |
ConcurrentWeakKeyHashMap.WeakKeyReference<K>
A weak-key reference which stores the key hash needed for reclamation.
|
(package private) class |
ConcurrentWeakKeyHashMap.WriteThroughEntry
Custom Entry class used by EntryIterator.next(), that relays setValue changes to the underlying map.
|
Modifier and Type | Field and Description |
---|---|
(package private) static int |
DEFAULT_CONCURRENCY_LEVEL
The default concurrency level for this table, used when not otherwise specified in a constructor.
|
(package private) static int |
DEFAULT_INITIAL_CAPACITY
The default initial capacity for this table, used when not otherwise specified in a constructor.
|
(package private) static float |
DEFAULT_LOAD_FACTOR
The default load factor for this table, used when not otherwise specified in a constructor.
|
(package private) java.util.Set<java.util.Map.Entry<K,V>> |
entrySet |
(package private) java.util.Set<K> |
keySet |
(package private) static int |
MAX_SEGMENTS
The maximum number of segments to allow; used to bound constructor arguments.
|
(package private) static int |
MAXIMUM_CAPACITY
The maximum capacity, used if a higher value is implicitly specified by either of the constructors with
arguments.
|
(package private) static int |
RETRIES_BEFORE_LOCK
Number of unsynchronized retries in size and containsValue methods before resorting to locking.
|
(package private) int |
segmentMask
Mask value for indexing into segments.
|
(package private) ConcurrentWeakKeyHashMap.Segment<K,V>[] |
segments
The segments, each of which is a specialized hash table
|
(package private) int |
segmentShift
Shift value for indexing within segments.
|
(package private) java.util.Collection<V> |
values |
Constructor and Description |
---|
ConcurrentWeakKeyHashMap()
Creates a new, empty map with a default initial capacity (16), reference types (weak keys, strong values),
default load factor (0.75) and concurrencyLevel (16).
|
ConcurrentWeakKeyHashMap(int initialCapacity)
Creates a new, empty map with the specified initial capacity, and with default reference types (weak keys, strong
values), load factor (0.75) and concurrencyLevel (16).
|
ConcurrentWeakKeyHashMap(int initialCapacity,
float loadFactor)
Creates a new, empty map with the specified initial capacity and load factor and with the default reference types
(weak keys, strong values), and concurrencyLevel (16).
|
ConcurrentWeakKeyHashMap(int initialCapacity,
float loadFactor,
int concurrencyLevel)
Creates a new, empty map with the specified initial capacity, load factor and concurrency level.
|
ConcurrentWeakKeyHashMap(java.util.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(java.lang.Object value)
Legacy method testing if some key maps into the specified value in this table.
|
boolean |
containsKey(java.lang.Object key)
Tests if the specified object is a key in this table.
|
boolean |
containsValue(java.lang.Object value)
Returns true if this map maps one or more keys to the specified value.
|
java.util.Enumeration<V> |
elements()
Returns an enumeration of the values in this table.
|
java.util.Set<java.util.Map.Entry<K,V>> |
entrySet()
Returns a
Set view of the mappings contained in this map. |
V |
get(java.lang.Object key)
Returns the value to which the specified key is mapped, or
null if this map contains no mapping for the
key. |
private static int |
hash(int h)
Applies a supplemental hash function to a given hashCode, which defends against poor quality hash functions.
|
private int |
hashOf(java.lang.Object key) |
boolean |
isEmpty()
Returns true if this map contains no key-value mappings.
|
java.util.Enumeration<K> |
keys()
Returns an enumeration of the keys in this table.
|
java.util.Set<K> |
keySet()
Returns a
Set view of the keys contained in this map. |
void |
purgeStaleEntries()
Removes any stale entries whose keys have been finalized.
|
V |
put(K key,
V value)
Maps the specified key to the specified value in this table.
|
void |
putAll(java.util.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 |
remove(java.lang.Object key)
Removes the key (and its corresponding value) from this map.
|
boolean |
remove(java.lang.Object key,
java.lang.Object value) |
V |
replace(K key,
V value) |
boolean |
replace(K key,
V oldValue,
V newValue) |
(package private) ConcurrentWeakKeyHashMap.Segment<K,V> |
segmentFor(int hash)
Returns the segment that should be used for key with given hash.
|
int |
size()
Returns the number of key-value mappings in this map.
|
java.util.Collection<V> |
values()
Returns a
Collection view of the values contained in this map. |
static final int DEFAULT_INITIAL_CAPACITY
static final float DEFAULT_LOAD_FACTOR
static final int DEFAULT_CONCURRENCY_LEVEL
static final int MAXIMUM_CAPACITY
static final int MAX_SEGMENTS
static final int RETRIES_BEFORE_LOCK
final int segmentMask
final int segmentShift
final ConcurrentWeakKeyHashMap.Segment<K,V>[] segments
java.util.Set<K> keySet
java.util.Collection<V> values
public ConcurrentWeakKeyHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)
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.java.lang.IllegalArgumentException
- if the initial capacity is negative or the load factor or concurrencyLevel are
nonpositive.public ConcurrentWeakKeyHashMap(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.java.lang.IllegalArgumentException
- if the initial capacity of elements is negative or the load factor is
nonpositivepublic ConcurrentWeakKeyHashMap(int initialCapacity)
initialCapacity
- the initial capacity. The implementation performs internal sizing to accommodate this many
elements.java.lang.IllegalArgumentException
- if the initial capacity of elements is negative.public ConcurrentWeakKeyHashMap()
public ConcurrentWeakKeyHashMap(java.util.Map<? extends K,? extends V> m)
m
- the mapprivate static int hash(int h)
final ConcurrentWeakKeyHashMap.Segment<K,V> segmentFor(int hash)
hash
- the hash code for the keyprivate int hashOf(java.lang.Object key)
public boolean isEmpty()
public int size()
public V get(java.lang.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.)
public boolean containsKey(java.lang.Object key)
containsKey
in interface java.util.Map<K,V>
containsKey
in class java.util.AbstractMap<K,V>
key
- possible keyjava.lang.NullPointerException
- if the specified key is nullpublic boolean containsValue(java.lang.Object value)
containsValue
in interface java.util.Map<K,V>
containsValue
in class java.util.AbstractMap<K,V>
value
- value whose presence in this map is to be testedjava.lang.NullPointerException
- if the specified value is nullpublic boolean contains(java.lang.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 forjava.lang.NullPointerException
- 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 java.util.Map<K,V>
put
in class java.util.AbstractMap<K,V>
key
- key with which the specified value is to be associatedvalue
- value to be associated with the specified keyjava.lang.NullPointerException
- if the specified key or value is nullpublic void putAll(java.util.Map<? extends K,? extends V> m)
public V remove(java.lang.Object key)
remove
in interface java.util.Map<K,V>
remove
in class java.util.AbstractMap<K,V>
key
- the key that needs to be removedjava.lang.NullPointerException
- if the specified key is nullpublic boolean remove(java.lang.Object key, java.lang.Object value)
public void clear()
public void purgeStaleEntries()
public java.util.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 java.util.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 java.util.Set<java.util.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 java.util.Enumeration<K> keys()
keySet()