Class UnlimitedConcurrentCache<K,​V>

    • Constructor Detail

      • UnlimitedConcurrentCache

        public UnlimitedConcurrentCache()
        Constructs a cache with unlimited size
      • UnlimitedConcurrentCache

        public UnlimitedConcurrentCache​(int initialCapacity)
        Constructs a cache with unlimited size and set its initial capacity
        Parameters:
        initialCapacity - the initial capacity
      • UnlimitedConcurrentCache

        public UnlimitedConcurrentCache​(Map<? extends K,​? extends V> m)
        Constructs a cache and initialize the cache with the specified map
        Parameters:
        m - the map to initialize the cache
    • Method Detail

      • remove

        public V remove​(Object key)
        Remove the cached value by the key
        Specified by:
        remove in interface EvictableCache<K,​V>
        Specified by:
        remove in interface Map<K,​V>
        Parameters:
        key -
        Returns:
        returns the removed value
      • putAll

        public void putAll​(Map<? extends K,​? extends V> m)
        Specified by:
        putAll in interface Map<K,​V>
      • keySet

        public Set<K> keySet()
        Specified by:
        keySet in interface Map<K,​V>
      • clearAll

        public Map<K,​V> clearAll()
        Clear the cache
        Specified by:
        clearAll in interface EvictableCache<K,​V>
        Returns:
        returns the content of the cleared map
      • clear

        public void clear()
        Clear the cache
        Specified by:
        clear in interface Map<K,​V>
        See Also:
        clearAll()
      • keys

        public Set<K> keys()
        Get all keys associated to cached values
        Specified by:
        keys in interface EvictableCache<K,​V>
        Returns:
        all keys
      • containsKey

        public boolean containsKey​(Object key)
        Determines if the cache contains an entry for the specified key.
        Specified by:
        containsKey in interface EvictableCache<K,​V>
        Specified by:
        containsKey in interface Map<K,​V>
        Parameters:
        key - key whose presence in this cache is to be tested.
        Returns:
        true if the cache contains a mapping for the specified key
      • size

        public int size()
        Get the size of the cache
        Specified by:
        size in interface EvictableCache<K,​V>
        Specified by:
        size in interface Map<K,​V>
        Returns:
        the size of the cache
      • isEmpty

        public boolean isEmpty()
        Specified by:
        isEmpty in interface Map<K,​V>
      • put

        public V put​(K key,
                     V value)
        Associates the specified value with the specified key in the cache.
        Specified by:
        put in interface Map<K,​V>
        Specified by:
        put in interface MemoizeCache<K,​V>
        Parameters:
        key - key with which the specified value is to be associated
        value - value to be associated with the specified key
        Returns:
        null, or the old value if the key associated with the specified key.
      • get

        public V get​(Object key)
        Gets a value from the cache
        Specified by:
        get in interface Map<K,​V>
        Specified by:
        get in interface MemoizeCache<K,​V>
        Parameters:
        key - the key whose associated value is to be returned
        Returns:
        the value, or null, if it does not exist.
      • cleanUpNullReferences

        public void cleanUpNullReferences()
        Replying on the ConcurrentHashMap thread-safe iteration implementation the method will remove all entries holding SoftReferences to gc-evicted objects.
        Specified by:
        cleanUpNullReferences in interface MemoizeCache<K,​V>