ConcurrentMap
data structure.See: Description
Interface | Description |
---|---|
ConcurrentHashMapV8.Action<A> |
Interface describing a void action of one argument
|
ConcurrentHashMapV8.BiAction<A,B> |
Interface describing a void action of two arguments
|
ConcurrentHashMapV8.BiFun<A,B,T> |
Interface describing a function of two arguments
|
ConcurrentHashMapV8.ConcurrentHashMapSpliterator<T> |
An object for traversing and partitioning elements of a source.
|
ConcurrentHashMapV8.DoubleByDoubleToDouble |
Interface describing a function mapping two doubles to a double
|
ConcurrentHashMapV8.Fun<A,T> |
Interface describing a function of one argument
|
ConcurrentHashMapV8.IntByIntToInt |
Interface describing a function mapping two ints to an int
|
ConcurrentHashMapV8.LongByLongToLong |
Interface describing a function mapping two longs to a long
|
ConcurrentHashMapV8.ObjectByObjectToDouble<A,B> |
Interface describing a function mapping two arguments to a double
|
ConcurrentHashMapV8.ObjectByObjectToInt<A,B> |
Interface describing a function mapping two arguments to an int
|
ConcurrentHashMapV8.ObjectByObjectToLong<A,B> |
Interface describing a function mapping two arguments to a long
|
ConcurrentHashMapV8.ObjectToDouble<A> |
Interface describing a function mapping its argument to a double
|
ConcurrentHashMapV8.ObjectToInt<A> |
Interface describing a function mapping its argument to an int
|
ConcurrentHashMapV8.ObjectToLong<A> |
Interface describing a function mapping its argument to a long
|
EntryWeigher<K,V> |
A class that can determine the weight of an entry.
|
EvictionListener<K,V> |
A listener registered for notification when an entry is evicted.
|
Linked<T extends Linked<T>> |
An element that is linked on the
Deque . |
Weigher<V> |
A class that can determine the weight of a value.
|
Class | Description |
---|---|
ConcurrentHashMapV8<K,V> |
A hash table supporting full concurrency of retrievals and
high expected concurrency for updates.
|
ConcurrentHashMapV8.BaseIterator<K,V> |
Base of key, value, and entry Iterators.
|
ConcurrentHashMapV8.CollectionView<K,V,E> |
Base class for views.
|
ConcurrentHashMapV8.CounterCell | |
ConcurrentHashMapV8.CounterHashCode |
Holder for the thread-local hash code determining which
CounterCell to use.
|
ConcurrentHashMapV8.EntryIterator<K,V> | |
ConcurrentHashMapV8.EntrySetView<K,V> |
A view of a ConcurrentHashMapV8 as a
Set of (key, value)
entries. |
ConcurrentHashMapV8.EntrySpliterator<K,V> | |
ConcurrentHashMapV8.ForwardingNode<K,V> |
A node inserted at head of bins during transfer operations.
|
ConcurrentHashMapV8.KeyIterator<K,V> | |
ConcurrentHashMapV8.KeySetView<K,V> |
A view of a ConcurrentHashMapV8 as a
Set of keys, in
which additions may optionally be enabled by mapping to a
common value. |
ConcurrentHashMapV8.KeySpliterator<K,V> | |
ConcurrentHashMapV8.MapEntry<K,V> |
Exported Entry for EntryIterator
|
ConcurrentHashMapV8.Node<K,V> |
Key-value entry.
|
ConcurrentHashMapV8.ReservationNode<K,V> |
A place-holder node used in computeIfAbsent and compute
|
ConcurrentHashMapV8.Segment<K,V> |
Stripped-down version of helper class used in previous version,
declared for the sake of serialization compatibility
|
ConcurrentHashMapV8.Traverser<K,V> |
Encapsulates traversal for methods such as containsValue; also
serves as a base class for other iterators and spliterators.
|
ConcurrentHashMapV8.TreeBin<K,V> |
TreeNodes used at the heads of bins.
|
ConcurrentHashMapV8.TreeNode<K,V> |
Nodes for use in TreeBins
|
ConcurrentHashMapV8.ValueIterator<K,V> | |
ConcurrentHashMapV8.ValueSpliterator<K,V> | |
ConcurrentHashMapV8.ValuesView<K,V> |
A view of a ConcurrentHashMapV8 as a
Collection of
values, in which additions are disabled. |
ConcurrentLinkedHashMap<K,V> |
A hash table supporting full concurrency of retrievals, adjustable expected
concurrency for updates, and a maximum capacity to bound the map by.
|
ConcurrentLinkedHashMap.BoundedEntryWeigher<K,V> |
A weigher that enforces that the weight falls within a valid range.
|
ConcurrentLinkedHashMap.Builder<K,V> |
A builder that creates
ConcurrentLinkedHashMap instances. |
ConcurrentLinkedHashMap.DiscardingQueue |
A queue that discards all additions and is always empty.
|
ConcurrentLinkedHashMap.Node<K,V> |
A node contains the key, the weighted value, and the linkage pointers on
the page-replacement algorithm's data structures.
|
ConcurrentLinkedHashMap.SerializationProxy<K,V> |
A proxy that is serialized instead of the map.
|
ConcurrentLinkedHashMap.WeightedValue<V> |
A value, its weight, and the entry's status.
|
LinkedDeque<E extends Linked<E>> |
Linked list implementation of the
Deque interface where the link
pointers are tightly integrated with the element. |
Weighers |
A common set of
Weigher and EntryWeigher implementations. |
Weighers.EntryWeigherView<K,V> |
Enum | Description |
---|---|
ConcurrentLinkedHashMap.DiscardingListener |
A listener that ignores all notifications.
|
ConcurrentLinkedHashMap.DrainStatus |
The draining status of the buffers.
|
Weighers.ByteArrayWeigher | |
Weighers.CollectionWeigher | |
Weighers.IterableWeigher | |
Weighers.ListWeigher | |
Weighers.MapWeigher | |
Weighers.SetWeigher | |
Weighers.SingletonEntryWeigher | |
Weighers.SingletonWeigher |
ConcurrentMap
data structure.
Weigher
is a simple interface
for determining how many units of capacity an entry consumes. Depending on
which concrete Weigher class is used, an entry may consume a different amount
of space within the cache. The
Weighers
class provides
utility methods for obtaining the most common kinds of implementations.
EvictionListener
provides the
ability to be notified when an entry is evicted from the map. An eviction
occurs when the entry was automatically removed due to the map exceeding a
capacity threshold. It is not called when an entry was explicitly removed.
The ConcurrentLinkedHashMap
class supplies an efficient, scalable, thread-safe, bounded map. As with the
Java Collections Framework the "Concurrent" prefix is used to
indicate that the map is not governed by a single exclusion lock.
Copyright © 2010-2020 Toolsverse. All Rights Reserved.