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 and description | 
|---|
                                Builder
                                () | 
                        
| 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.  | 
                        
Creates a new ConcurrentLinkedHashMap instance.
Specifies the estimated number of concurrently updating threads. The implementation performs internal sizing to try to accommodate this many threads (default 16).
concurrencyLevel -  the estimated number of concurrently updating
     threadsSpecifies 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.
initialCapacity -  the initial capacity used to size the hash table
     to accommodate this many entries.Specifies an optional listener that is registered for notification when an entry is evicted.
listener -  the object to forward evicted entries toSpecifies the maximum weighted capacity to coerce the map to and may exceed it temporarily.
capacity -  the weighted threshold to bound the map bySpecifies 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.
weigher -  the algorithm to determine a value's weightSpecifies 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.
weigher -  the algorithm to determine a entry's weightCopyright © 2003-2020 The Apache Software Foundation. All rights reserved.