Package: org.apache.groovy.util.concurrentlinkedhashmap

## [Java] Class Builder<K, V>

- org.apache.groovy.util.concurrentlinkedhashmap.ConcurrentLinkedHashMap.Builder

- 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 and description
    `ConcurrentLinkedHashMap.Builder ()`

  - ### Methods Summary

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

  - ### Inherited Methods Summary

    Inherited Methods
    Methods inherited from class | Name
    --- | ---
    `class Object` | `wait, wait, wait, equals, toString, hashCode, getClass, notify, notifyAll`

- - ### Constructor Detail

    - #### @SuppressWarnings("unchecked") public ConcurrentLinkedHashMap.Builder()

  - ### Method Detail

    - #### public ConcurrentLinkedHashMap<K, V> build()

      Creates a new ConcurrentLinkedHashMap instance.

      throws:
        IllegalStateException if the maximum weighted capacity was not set

    - #### public 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`).

      throws:
        IllegalArgumentException if the concurrencyLevel is less than or equal to zero
      Parameters:
        `concurrencyLevel` - the estimated number of concurrently updating threads

    - #### public 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.

      throws:
        IllegalArgumentException if the initialCapacity is negative
      Parameters:
        `initialCapacity` - the initial capacity used to size the hash table to accommodate this many entries.

    - #### public Builder<K, V> listener(EvictionListener<K, V> listener)

      Specifies an optional listener that is registered for notification when an entry is evicted.

      throws:
        NullPointerException if the listener is null
      Parameters:
        `listener` - the object to forward evicted entries to

    - #### public Builder<K, V> maximumWeightedCapacity(long capacity)

      Specifies the maximum weighted capacity to coerce the map to and may exceed it temporarily.

      throws:
        IllegalArgumentException if the maximumWeightedCapacity is negative
      Parameters:
        `capacity` - the weighted threshold to bound the map by

    - #### public 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`.

      throws:
        NullPointerException if the weigher is null
      Parameters:
        `weigher` - the algorithm to determine a value's weight

    - #### public 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`.

      throws:
        NullPointerException if the weigher is null
      Parameters:
        `weigher` - the algorithm to determine a entry's weight