org.apache.groovy.util.concurrentlinkedhashmap

## Class ConcurrentLinkedHashMap.Builder<K,V>

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

- Enclosing class:
    ConcurrentLinkedHashMap<K,V>

      public static final class ConcurrentLinkedHashMap.Builder<K,V>
      extends java.lang.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 and Description
    `Builder()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and 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 Detail

    - #### Builder

          public Builder()

  - ### Method Detail

    - #### 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:
        `java.lang.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:
        `java.lang.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:
        `java.lang.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:
        `java.lang.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:
        `java.lang.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:
        `java.lang.NullPointerException` - if the weigher is null

    - #### build

          public ConcurrentLinkedHashMap<K,V> build()

      Creates a new `ConcurrentLinkedHashMap` instance.
      Throws:
        `java.lang.IllegalStateException` - if the maximum weighted capacity was not set