Package 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 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

    All Methods Instance Methods Concrete Methods
    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 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:
        `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