org.apache.avro.util

## Class WeakIdentityHashMap<K,V>

- java.lang.Object
- - org.apache.avro.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,V>`

### Constructor Summary

Constructors
Constructor and Description
`WeakIdentityHashMap()`

### Method Summary

All Methods Instance Methods Concrete Methods
`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 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 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>`