ConcurrentLinkedHashMap (groovy 3.0.0 API)

org.apache.groovy.util.concurrent.concurrentlinkedhashmap.ConcurrentLinkedHashMap

All Implemented Interfaces and Traits:

ConcurrentMap, Serializable
```
@com.github.javaparser.ast.expr.MarkerAnnotationExprThreadSafe
public final class ConcurrentLinkedHashMap
extends AbstractMap
```
A hash table supporting full concurrency of retrievals, adjustable expected concurrency for updates, and a maximum capacity to bound the map by. This implementation differs from ConcurrentHashMap in that it maintains a page replacement algorithm that is used to evict an entry when the map has exceeded its capacity. Unlike the Java Collections Framework, this map does not have a publicly visible constructor and instances are created through a Builder.
An entry is evicted from the map when the weighted capacity exceeds its maximum weighted capacity threshold. A EntryWeigher determines how many units of capacity that an entry consumes. The default weigher assigns each value a weight of 1 to bound the map by the total number of key-value pairs. A map that holds collections may choose to weigh values by the number of elements in the collection and bound the map by the total number of elements that it contains. A change to a value that modifies its weight requires that an update operation is performed on the map.
An EvictionListener may be supplied for notification when an entry is evicted from the map. This listener is invoked on a caller's thread and will not block other threads from operating on the map. An implementation should be aware that the caller's thread will not expect long execution times or failures as a side effect of the listener being notified. Execution safety and a fast turn around time can be achieved by performing the operation asynchronously, such as by submitting a task to an ExecutorService.
The concurrency level determines the number of threads that can concurrently modify the table. Using a significantly higher or lower value than needed can waste space or lead to thread contention, but an estimate within an order of magnitude of the ideal value does not usually have a noticeable impact. Because placement in hash tables is essentially random, the actual concurrency will vary.
This class and its views and iterators implement all of the optional methods of the Map and Iterator interfaces.
Like Hashtable but unlike HashMap, this class does not allow null to be used as a key or value. Unlike LinkedHashMap, this class does not provide predictable iteration order. A snapshot of the keys and entries may be obtained in ascending and descending order of retention.
Parameters:
- the type of keys maintained by this map
- the type of mapped values
See Also:
http://code.google.com/p/concurrentlinkedhashmap/

Nested Class Summary

Nested classes
Modifiers	Name	Description
`static class`	`ConcurrentLinkedHashMap.Builder`	A builder that creates ConcurrentLinkedHashMap instances.

Methods Summary

Methods
Type Params	Return Type	Name and description
	`Set<K>`	`ascendingKeySet()` Returns a unmodifiable snapshot Set view of the keys contained in this map.
	`Set<K>`	`ascendingKeySetWithLimit(int limit)` Returns an unmodifiable snapshot Set view of the keys contained in this map.
	`Map<K, V>`	`ascendingMap()` Returns an unmodifiable snapshot Map view of the mappings contained in this map.
	`Map<K, V>`	`ascendingMapWithLimit(int limit)` Returns an unmodifiable snapshot Map view of the mappings contained in this map.
	`long`	`capacity()` Retrieves the maximum weighted capacity of the map.
	`void`	`clear()`
	`V`	`computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)` If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map unless `null`.
	`boolean`	`containsKey(Object key)`
	`boolean`	`containsValue(Object value)`
	`Set<K>`	`descendingKeySet()` Returns an unmodifiable snapshot Set view of the keys contained in this map.
	`Set<K>`	`descendingKeySetWithLimit(int limit)` Returns an unmodifiable snapshot Set view of the keys contained in this map.
	`Map<K, V>`	`descendingMap()` Returns an unmodifiable snapshot Map view of the mappings contained in this map.
	`Map<K, V>`	`descendingMapWithLimit(int limit)` Returns an unmodifiable snapshot Map view of the mappings contained in this map.
	`Set<Entry<K, V>>`	`entrySet()`
	`V`	`get(Object key)`
	`V`	`getQuietly(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()`
	`Set<K>`	`keySet()`
	`V`	`put(K key, V value)`
	`V`	`putIfAbsent(K key, V value)`
	`V`	`remove(Object key)`
	`boolean`	`remove(Object key, Object value)`
	`V`	`replace(K key, V value)`
	`boolean`	`replace(K key, V oldValue, V newValue)`
	`void`	`setCapacity(long capacity)` Sets the maximum weighted capacity of the map and eagerly evicts entries until it shrinks to the appropriate size.
	`int`	`size()`
	`Collection<V>`	`values()`
	`long`	`weightedSize()` Returns the weighted size of this map.

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class AbstractMap`	`remove, get, put, equals, toString, values, hashCode, clear, isEmpty, size, entrySet, putAll, keySet, containsKey, containsValue, wait, wait, wait, getClass, notify, notifyAll, remove, replace, replace, replaceAll, putIfAbsent, forEach, compute, computeIfAbsent, computeIfPresent, getOrDefault, merge`

- Method Detail
  - public Set<K> ascendingKeySet()
    
    Returns a unmodifiable snapshot Set view of the keys contained in this map. The set's iterator returns the keys whose order of iteration is the ascending order in which its entries are considered eligible for retention, from the least-likely to be retained to the most-likely.
    Beware that, unlike in keySet(), obtaining the set is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the keys.
    Returns:
    an ascending snapshot view of the keys in this map
  - public Set<K> ascendingKeySetWithLimit(int limit)
    
    Returns an unmodifiable snapshot Set view of the keys contained in this map. The set's iterator returns the keys whose order of iteration is the ascending order in which its entries are considered eligible for retention, from the least-likely to be retained to the most-likely.
    Beware that, unlike in keySet(), obtaining the set is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the keys.
    throws:
    IllegalArgumentException if the limit is negative
    
    Parameters:
    limit - the maximum size of the returned set
    Returns:
    a ascending snapshot view of the keys in this map
  - public Map<K, V> ascendingMap()
    
    Returns an unmodifiable snapshot Map view of the mappings contained in this map. The map's collections return the mappings whose order of iteration is the ascending order in which its entries are considered eligible for retention, from the least-likely to be retained to the most-likely.
    Beware that obtaining the mappings is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the entries.
    Returns:
    a ascending snapshot view of this map
  - public Map<K, V> ascendingMapWithLimit(int limit)
    
    Returns an unmodifiable snapshot Map view of the mappings contained in this map. The map's collections return the mappings whose order of iteration is the ascending order in which its entries are considered eligible for retention, from the least-likely to be retained to the most-likely.
    Beware that obtaining the mappings is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the entries.
    throws:
    IllegalArgumentException if the limit is negative
    
    Parameters:
    limit - the maximum size of the returned map
    Returns:
    a ascending snapshot view of this map
  - public long capacity()
    
    Retrieves the maximum weighted capacity of the map.
    Returns:
    the maximum weighted capacity
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public void clear()
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
    
    If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map unless null. The entire method invocation is performed atomically, so the function is applied at most once per key. Some attempted update operations on this map by other threads may be blocked while computation is in progress, so the computation should be short and simple, and must not attempt to update any other mappings of this map.
    throws:
    NullPointerException if the specified key or mappingFunction is null
    throws:
    IllegalStateException if the computation detectably attempts a recursive update to this map that would otherwise never complete
    throws:
    RuntimeException or Error if the mappingFunction does so, in which case the mapping is left unestablished
    
    Parameters:
    key - key with which the specified value is to be associated
    mappingFunction - the function to compute a value
    Returns:
    the current (existing or computed) value associated with the specified key, or null if the computed value is null
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean containsKey(Object key)
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean containsValue(Object value)
  - public Set<K> descendingKeySet()
    
    Returns an unmodifiable snapshot Set view of the keys contained in this map. The set's iterator returns the keys whose order of iteration is the descending order in which its entries are considered eligible for retention, from the most-likely to be retained to the least-likely.
    Beware that, unlike in keySet(), obtaining the set is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the keys.
    Returns:
    a descending snapshot view of the keys in this map
  - public Set<K> descendingKeySetWithLimit(int limit)
    
    Returns an unmodifiable snapshot Set view of the keys contained in this map. The set's iterator returns the keys whose order of iteration is the descending order in which its entries are considered eligible for retention, from the most-likely to be retained to the least-likely.
    Beware that, unlike in keySet(), obtaining the set is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the keys.
    throws:
    IllegalArgumentException if the limit is negative
    
    Parameters:
    limit - the maximum size of the returned set
    Returns:
    a descending snapshot view of the keys in this map
  - public Map<K, V> descendingMap()
    
    Returns an unmodifiable snapshot Map view of the mappings contained in this map. The map's collections return the mappings whose order of iteration is the descending order in which its entries are considered eligible for retention, from the most-likely to be retained to the least-likely.
    Beware that obtaining the mappings is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the entries.
    Returns:
    a descending snapshot view of this map
  - public Map<K, V> descendingMapWithLimit(int limit)
    
    Returns an unmodifiable snapshot Map view of the mappings contained in this map. The map's collections return the mappings whose order of iteration is the descending order in which its entries are considered eligible for retention, from the most-likely to be retained to the least-likely.
    Beware that obtaining the mappings is NOT a constant-time operation. Because of the asynchronous nature of the page replacement policy, determining the retention ordering requires a traversal of the entries.
    throws:
    IllegalArgumentException if the limit is negative
    
    Parameters:
    limit - the maximum size of the returned map
    Returns:
    a descending snapshot view of this map
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public Set<Entry<K, V>> entrySet()
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V get(Object key)
  - public V getQuietly(Object key)
    
    Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key. This method differs from get(Object) in that it does not record the operation with the page replacement policy.
    throws:
    NullPointerException if the specified key is null
    
    Parameters:
    key - the key whose associated value is to be returned
    Returns:
    the value to which the specified key is mapped, or null if this map contains no mapping for the key
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean isEmpty()
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public Set<K> keySet()
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V put(K key, V value)
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V putIfAbsent(K key, V value)
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V remove(Object key)
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean remove(Object key, Object value)
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V replace(K key, V value)
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean replace(K key, V oldValue, V newValue)
  - public void setCapacity(long capacity)
    
    Sets the maximum weighted capacity of the map and eagerly evicts entries until it shrinks to the appropriate size.
    throws:
    IllegalArgumentException if the capacity is negative
    
    Parameters:
    capacity - the maximum weighted capacity of the map
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public int size()
  - @com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public Collection<V> values()
  - public long weightedSize()
    
    Returns the weighted size of this map.
    Returns:
    the combined weight of the values in this map

Summary:
Nested
Method

| Detail:
Method

[Java] Class ConcurrentLinkedHashMapK, V

Nested Class Summary

Methods Summary

Inherited Methods Summary

Method Detail

public Set<K> ascendingKeySet()

public Set<K> ascendingKeySetWithLimit(int limit)

public Map<K, V> ascendingMap()

public Map<K, V> ascendingMapWithLimit(int limit)

public long capacity()

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public void clear()

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean containsKey(Object key)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean containsValue(Object value)

public Set<K> descendingKeySet()

public Set<K> descendingKeySetWithLimit(int limit)

public Map<K, V> descendingMap()

public Map<K, V> descendingMapWithLimit(int limit)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public Set<Entry<K, V>> entrySet()

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V get(Object key)

public V getQuietly(Object key)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean isEmpty()

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public Set<K> keySet()

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V put(K key, V value)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V putIfAbsent(K key, V value)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V remove(Object key)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean remove(Object key, Object value)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public V replace(K key, V value)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public boolean replace(K key, V oldValue, V newValue)

public void setCapacity(long capacity)

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public int size()

@com.github.javaparser.ast.expr.MarkerAnnotationExprOverride public Collection<V> values()

public long weightedSize()