Package org.apache.cxf.common.util

## Class CacheMap<K,​V>

- java.lang.Object
- - org.apache.cxf.common.util.CacheMap<K,​V>

- All Implemented Interfaces:
    `Map<K,​V>`

      public class CacheMap<K,​V>
      extends Object
      implements Map<K,​V>

  Implements a useful caching map. It weakly references the keys, but strongly references the data. It works much like the WeakHashMap, in that when the keys are garbage collected, the data is removed from the map. The main difference is that keys used for lookups don't have to be "==" the same to maintain the data in the cache. Basically, lookups in this map use a ".equals" compare, but the keys are then stored with a "==" compare so if the original key is garbage collected, the other keys that may reference the data keep the data in the cache. Note that this implementation is not synchronized. Not even a little. 'Read-only' operations can trigger internal modifications. If you share this class between threads, you must protect every operation.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface java.util.Map

      `Map.Entry<K extends Object,​V extends Object>`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `CacheMap()` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `clear()` |
    `boolean` | `containsKey​(Object key)` |
    `boolean` | `containsValue​(Object value)` |
    `Set<Map.Entry<K,​V>>` | `entrySet()` |
    `V` | `get​(Object key)` |
    `boolean` | `isEmpty()` |
    `Set<K>` | `keySet()` |
    `V` | `put​(K key, V value)` |
    `void` | `putAll​(Map<? extends K,​? extends V> t)` |
    `V` | `remove​(Object key)` |
    `int` | `size()` |
    `String` | `toString()` |
    `Collection<V>` | `values()` |

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface java.util.Map

      `compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll`

- - ### Constructor Detail

    - #### CacheMap

          public CacheMap()

  - ### Method Detail

    - #### clear

          public void clear()

      Specified by:
        `clear` in interface `Map<K,​V>`

    - #### containsKey

          public boolean containsKey​(Object key)

      Specified by:
        `containsKey` in interface `Map<K,​V>`

    - #### containsValue

          public boolean containsValue​(Object value)

      Specified by:
        `containsValue` in interface `Map<K,​V>`

    - #### entrySet

          public Set<Map.Entry<K,​V>> entrySet()

      Specified by:
        `entrySet` in interface `Map<K,​V>`

    - #### get

          public V get​(Object key)

      Specified by:
        `get` in interface `Map<K,​V>`

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` in interface `Map<K,​V>`

    - #### keySet

          public Set<K> keySet()

      Specified by:
        `keySet` in interface `Map<K,​V>`

    - #### put

          public V put​(K key,
                       V value)

      Specified by:
        `put` in interface `Map<K,​V>`

    - #### putAll

          public void putAll​(Map<? extends K,​? extends V> t)

      Specified by:
        `putAll` in interface `Map<K,​V>`

    - #### remove

          public V remove​(Object key)

      Specified by:
        `remove` in interface `Map<K,​V>`

    - #### size

          public int size()

      Specified by:
        `size` in interface `Map<K,​V>`

    - #### values

          public Collection<V> values()

      Specified by:
        `values` in interface `Map<K,​V>`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`