Package org.apache.groovy.util.concurrent.concurrentlinkedhashmap

# Class ConcurrentLinkedHashMap.Builder<K,​V>

java.lang.Object
org.apache.groovy.util.concurrent.concurrentlinkedhashmap.ConcurrentLinkedHashMap.Builder<K,​V>

Enclosing class:
  ConcurrentLinkedHashMap<K,​V>

    public static final class ConcurrentLinkedHashMap.Builder<K,​V>
    extends Object

A builder that creates `ConcurrentLinkedHashMap` instances. It provides a flexible approach for constructing customized instances with a named parameter syntax. It can be used in the following manner:

     ConcurrentMap<Vertex, Set<Edge>> graph = new Builder<Vertex, Set<Edge>>()
         .maximumWeightedCapacity(5000)
         .weigher(Weighers.<Edge>set())
         .build();

- ## Constructor Summary

  Constructors
  Constructor | Description
  --- | ---
  `Builder()` |

- ## Method Summary

  Modifier and Type | Method | Description
  --- | --- | ---
  `ConcurrentLinkedHashMap<K,​V>` | `build()` | Creates a new `ConcurrentLinkedHashMap` instance.
  `ConcurrentLinkedHashMap.Builder<K,​V>` | `concurrencyLevel​(int concurrencyLevel)` | Specifies the estimated number of concurrently updating threads.
  `ConcurrentLinkedHashMap.Builder<K,​V>` | `initialCapacity​(int initialCapacity)` | Specifies the initial capacity of the hash table (default `16`).
  `ConcurrentLinkedHashMap.Builder<K,​V>` | `listener​(EvictionListener<K,​V> listener)` | Specifies an optional listener that is registered for notification when an entry is evicted.
  `ConcurrentLinkedHashMap.Builder<K,​V>` | `maximumWeightedCapacity​(long capacity)` | Specifies the maximum weighted capacity to coerce the map to and may exceed it temporarily.
  `ConcurrentLinkedHashMap.Builder<K,​V>` | `weigher​(EntryWeigher<? super K,​? super V> weigher)` | Specifies an algorithm to determine how many the units of capacity an entry consumes.
  `ConcurrentLinkedHashMap.Builder<K,​V>` | `weigher​(Weigher<? super V> weigher)` | Specifies an algorithm to determine how many the units of capacity a value consumes.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### Builder

    public Builder()

- ## Method Details

  - ### initialCapacity

    public ConcurrentLinkedHashMap.Builder<K,​V> initialCapacity​(int initialCapacity)
    Specifies the initial capacity of the hash table (default `16`). This is the number of key-value pairs that the hash table can hold before a resize operation is required.
    Parameters:
      `initialCapacity` - the initial capacity used to size the hash table to accommodate this many entries.
    Throws:
      `IllegalArgumentException` - if the initialCapacity is negative

  - ### maximumWeightedCapacity

    public ConcurrentLinkedHashMap.Builder<K,​V> maximumWeightedCapacity​(long capacity)
    Specifies the maximum weighted capacity to coerce the map to and may exceed it temporarily.
    Parameters:
      `capacity` - the weighted threshold to bound the map by
    Throws:
      `IllegalArgumentException` - if the maximumWeightedCapacity is negative

  - ### concurrencyLevel

    public ConcurrentLinkedHashMap.Builder<K,​V> concurrencyLevel​(int concurrencyLevel)
    Specifies the estimated number of concurrently updating threads. The implementation performs internal sizing to try to accommodate this many threads (default `16`).
    Parameters:
      `concurrencyLevel` - the estimated number of concurrently updating threads
    Throws:
      `IllegalArgumentException` - if the concurrencyLevel is less than or equal to zero

  - ### listener

    public ConcurrentLinkedHashMap.Builder<K,​V> listener​(EvictionListener<K,​V> listener)
    Specifies an optional listener that is registered for notification when an entry is evicted.
    Parameters:
      `listener` - the object to forward evicted entries to
    Throws:
      `NullPointerException` - if the listener is null

  - ### weigher

    public ConcurrentLinkedHashMap.Builder<K,​V> weigher​(Weigher<? super V> weigher)
    Specifies an algorithm to determine how many the units of capacity a value consumes. The default algorithm bounds the map by the number of key-value pairs by giving each entry a weight of `1`.
    Parameters:
      `weigher` - the algorithm to determine a value's weight
    Throws:
      `NullPointerException` - if the weigher is null

  - ### weigher

    public ConcurrentLinkedHashMap.Builder<K,​V> weigher​(EntryWeigher<? super K,​? super V> weigher)
    Specifies an algorithm to determine how many the units of capacity an entry consumes. The default algorithm bounds the map by the number of key-value pairs by giving each entry a weight of `1`.
    Parameters:
      `weigher` - the algorithm to determine a entry's weight
    Throws:
      `NullPointerException` - if the weigher is null

  - ### build

    public ConcurrentLinkedHashMap<K,​V> build()
    Creates a new `ConcurrentLinkedHashMap` instance.
    Throws:
      `IllegalStateException` - if the maximum weighted capacity was not set