public class CommonCache<K, V> extends Object implements EvictableCache, ValueConvertable, Serializable
Represents a simple key-value cache, which is NOT thread safe and backed by a Map instance
K -  type of the keysV -  type of the values| Modifiers | Name | Description | 
|---|---|---|
static int  | 
                            DEFAULT_INITIAL_CAPACITY | 
                            The default initial capacity | 
static float  | 
                            DEFAULT_LOAD_FACTOR | 
                            The default load factor | 
| Constructor and description | 
|---|
                                CommonCache
                                ()Constructs a cache with unlimited size  | 
                        
                                CommonCache
                                (int initialCapacity, int maxSize, EvictionStrategy evictionStrategy)Constructs a cache with limited size  | 
                        
                                CommonCache
                                (int initialCapacity, int maxSize)Constructs a LRU cache with the specified initial capacity and max size.  | 
                        
                                CommonCache
                                (int maxSize)Constructs a LRU cache with the default initial capacity  | 
                        
                                CommonCache
                                (Map<K, V> map)Constructs a cache backed by the specified Map instance  | 
                        
| Type Params | Return Type | Name and description | 
|---|---|---|
 | 
                            public void | 
                            cleanUpNullReferences(){@inheritDoc}  | 
                        
 | 
                            public Map<K, V> | 
                            clearAll(){@inheritDoc}  | 
                        
 | 
                            public boolean | 
                            containsKey(Object key){@inheritDoc}  | 
                        
 | 
                            public boolean | 
                            containsValue(Object value) | 
                        
 | 
                            public Object | 
                            convertValue(V value){@inheritDoc}  | 
                        
 | 
                            public Set<Entry<K, V>> | 
                            entrySet() | 
                        
 | 
                            public V | 
                            get(Object key){@inheritDoc}  | 
                        
 | 
                            public V | 
                            getAndPut(K key, ValueProvider<? super K, ? extends V> valueProvider){@inheritDoc}  | 
                        
 | 
                            public V | 
                            getAndPut(K key, ValueProvider<? super K, ? extends V> valueProvider, boolean shouldCache) | 
                        
 | 
                            public boolean | 
                            isEmpty() | 
                        
 | 
                            public Set<K> | 
                            keySet() | 
                        
 | 
                            public Set<K> | 
                            keys(){@inheritDoc}  | 
                        
 | 
                            public V | 
                            put(K key, V value){@inheritDoc}  | 
                        
 | 
                            public void | 
                            putAll(Map<? extends K, ? extends V> m) | 
                        
 | 
                            public V | 
                            remove(Object key){@inheritDoc}  | 
                        
 | 
                            protected boolean | 
                            removeEldestEntry(Map.Entry<K, V> eldest) | 
                        
 | 
                            public int | 
                            size(){@inheritDoc}  | 
                        
 | 
                            public String | 
                            toString() | 
                        
 | 
                            public Collection<V> | 
                            values(){@inheritDoc}  | 
                        
The default initial capacity
The default load factor
Constructs a cache with unlimited size
Constructs a cache with limited size
initialCapacity -   initial capacity of the cachemaxSize -           max size of the cacheevictionStrategy -  LRU or FIFO, see org.codehaus.groovy.runtime.memoize.EvictableCache.EvictionStrategyConstructs a LRU cache with the specified initial capacity and max size. The LRU cache is slower than LRUCache
initialCapacity -  initial capacity of the LRU cachemaxSize -          max size of the LRU cacheConstructs a LRU cache with the default initial capacity
maxSize -  max size of the LRU cache{@inheritDoc}
{@inheritDoc}
{@inheritDoc}
{@inheritDoc}
{@inheritDoc}
Copyright © 2003-2020 The Apache Software Foundation. All rights reserved.