WeakIdentityHashMap (Apache CXF JavaDoc 3.6.11 API)

Package org.apache.cxf.common.util

## Class WeakIdentityHashMap<K,​V>

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

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

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

  Implements a combination of WeakHashMap and IdentityHashMap. Useful for caches that need to key off of a == comparison instead of a .equals. This class is not a general-purpose Map implementation! While this class implements the Map interface, it intentionally violates Map's general contract, which mandates the use of the equals method when comparing objects. This class is designed for use only in the rare cases wherein reference-equality semantics are required. Note that this implementation is not synchronized.

- - ### 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
    --- | ---
    `WeakIdentityHashMap()` |

  - ### 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()` |
    `boolean` | `equals​(Object o)` |
    `V` | `get​(Object key)` |
    `int` | `hashCode()` |
    `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()` |
    `Collection<V>` | `values()` |

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

      `clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

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

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

- - ### Constructor Detail

    - #### WeakIdentityHashMap

          public WeakIdentityHashMap()

  - ### 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>`

    - #### keySet

          public Set<K> keySet()

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

    - #### equals

          public boolean equals​(Object o)

      Specified by:
        `equals` in interface `Map<K,​V>`
      Overrides:
        `equals` in class `Object`

    - #### get

          public V get​(Object key)

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

    - #### put

          public V put​(K key,
                       V value)

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

    - #### hashCode

          public int hashCode()

      Specified by:
        `hashCode` in interface `Map<K,​V>`
      Overrides:
        `hashCode` in class `Object`

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` 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>`