com.fasterxml.jackson.databind.util

## Class LRUMap<K,V>

- java.lang.Object
- - java.util.AbstractMap<K,V>
  - - java.util.HashMap<K,V>
    - - java.util.LinkedHashMap<K,V>
      - - com.fasterxml.jackson.databind.util.LRUMap<K,V>

All Implemented Interfaces:
  Serializable, Cloneable, Map<K,V>

    public class LRUMap<K,V>
    extends LinkedHashMap<K,V>
    implements Serializable

Helper for simple bounded LRU maps used for reusing lookup values.

Note that serialization behavior is such that contents are NOT serialized, on assumption that all use cases are for caching where persistence does not make sense. The only thing serialized is the cache size of Map.

NOTE: the only reason we extend `LinkedHashMap` instead of aggregating it is that this way we can override `removeEldestEntry(java.util.Map.Entry<K, V>)`. Access, however, MUST be done using single-element access methods (or matching `xxxAll()` methods that call them); access via iterators are not guaranteed to work.

NOTE: since version 2.4, uses `ReentrantReadWriteLock` to improve concurrent access.

See Also:
  Serialized Form

### Nested Class Summary

### Nested classes/interfaces inherited from class java.util.AbstractMap

`AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>`

### Field Summary

Fields
`protected int` `_jdkSerializeMaxEntries` Ugly hack, to work through the requirement that _value is indeed final, and that JDK serialization won't call ctor(s) if Serializable is implemented.
`protected int` `_maxEntries`
`protected Lock` `_readLock`
`protected Lock` `_writeLock`

### Constructor Summary

Constructors
Constructor and Description
`LRUMap(int initialEntries, int maxEntries)`

### Method Summary

Methods
`void` `clear()` Overridden to allow concurrent way of removing all cached entries.
`V` `get(Object key)`
`V` `put(K key, V value)`
`protected Object` `readResolve()`
`V` `remove(Object key)`
`protected boolean` `removeEldestEntry(Map.Entry<K,V> eldest)`

### Methods inherited from class java.util.LinkedHashMap

`containsValue`

### Methods inherited from class java.util.HashMap

`clone, containsKey, entrySet, isEmpty, keySet, putAll, size, values`

### Methods inherited from class java.util.AbstractMap

`equals, hashCode, toString`

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

`finalize, getClass, notify, notifyAll, wait, wait, wait`

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

`containsKey, entrySet, equals, hashCode, isEmpty, keySet, putAll, size, values`

### Field Detail

#### _readLock

    protected final transient Lock _readLock

#### _writeLock

    protected final transient Lock _writeLock

#### _maxEntries

    protected final transient int _maxEntries

#### _jdkSerializeMaxEntries

    protected transient int _jdkSerializeMaxEntries

Ugly hack, to work through the requirement that _value is indeed final, and that JDK serialization won't call ctor(s) if Serializable is implemented.

Since:
  2.1

### Constructor Detail

#### LRUMap

    public LRUMap(int initialEntries,
          int maxEntries)

### Method Detail

#### removeEldestEntry

    protected boolean removeEldestEntry(Map.Entry<K,V> eldest)

Overrides:
  `removeEldestEntry` in class `LinkedHashMap<K,V>`

#### get

    public V get(Object key)

Specified by:
  `get` in interface `Map<K,V>`
Overrides:
  `get` in class `LinkedHashMap<K,V>`

#### put

    public V put(K key,
        V value)

Specified by:
  `put` in interface `Map<K,V>`
Overrides:
  `put` in class `HashMap<K,V>`

#### remove

    public V remove(Object key)

Specified by:
  `remove` in interface `Map<K,V>`
Overrides:
  `remove` in class `HashMap<K,V>`

#### clear

    public void clear()

Overridden to allow concurrent way of removing all cached entries.

Specified by:
  `clear` in interface `Map<K,V>`
Overrides:
  `clear` in class `LinkedHashMap<K,V>`
Since:
  2.4.1

#### readResolve

    protected Object readResolve()