java.lang.Object
- java.util.AbstractMap<K,V>
- - com.google.common.cache.LocalCache<K,V>

All Implemented Interfaces:

java.util.concurrent.ConcurrentMap<K,V>, java.util.Map<K,V>
```
class LocalCache<K,V>
extends java.util.AbstractMap<K,V>
implements java.util.concurrent.ConcurrentMap<K,V>
```
The concurrent hash map implementation built by CacheBuilder.
This implementation is heavily derived from revision 1.96 of ConcurrentHashMap.java.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`(package private) class`	`LocalCache.AbstractCacheSet<T>`
`(package private) static class`	`LocalCache.AbstractReferenceEntry<K,V>`
`(package private) static class`	`LocalCache.AccessQueue<K,V>`	A custom queue for managing access order.
`(package private) static class`	`LocalCache.EntryFactory`	Creates new entries.
`(package private) class`	`LocalCache.EntryIterator`
`(package private) class`	`LocalCache.EntrySet`
`(package private) class`	`LocalCache.HashIterator<T>`
`(package private) class`	`LocalCache.KeyIterator`
`(package private) class`	`LocalCache.KeySet`
`(package private) static class`	`LocalCache.LoadingSerializationProxy<K,V>`	Serializes the configuration of a LocalCache, reconstituting it as an LoadingCache using CacheBuilder upon deserialization.
`(package private) static class`	`LocalCache.LoadingValueReference<K,V>`
`(package private) static class`	`LocalCache.LocalLoadingCache<K,V>`
`(package private) static class`	`LocalCache.LocalManualCache<K,V>`
`(package private) static class`	`LocalCache.ManualSerializationProxy<K,V>`	Serializes the configuration of a LocalCache, reconstituting it as a Cache using CacheBuilder upon deserialization.
`private static class`	`LocalCache.NullEntry`
`(package private) static class`	`LocalCache.Segment<K,V>`	Segments are specialized versions of hash tables.
`(package private) static class`	`LocalCache.SoftValueReference<K,V>`	References a soft value.
`(package private) static class`	`LocalCache.Strength`
`(package private) static class`	`LocalCache.StrongAccessEntry<K,V>`
`(package private) static class`	`LocalCache.StrongAccessWriteEntry<K,V>`
`(package private) static class`	`LocalCache.StrongEntry<K,V>`	Used for strongly-referenced keys.
`(package private) static class`	`LocalCache.StrongValueReference<K,V>`	References a strong value.
`(package private) static class`	`LocalCache.StrongWriteEntry<K,V>`
`(package private) class`	`LocalCache.ValueIterator`
`(package private) static interface`	`LocalCache.ValueReference<K,V>`	A reference to a value.
`(package private) class`	`LocalCache.Values`
`(package private) static class`	`LocalCache.WeakAccessEntry<K,V>`
`(package private) static class`	`LocalCache.WeakAccessWriteEntry<K,V>`
`(package private) static class`	`LocalCache.WeakEntry<K,V>`	Used for weakly-referenced keys.
`(package private) static class`	`LocalCache.WeakValueReference<K,V>`	References a weak value.
`(package private) static class`	`LocalCache.WeakWriteEntry<K,V>`
`(package private) static class`	`LocalCache.WeightedSoftValueReference<K,V>`	References a soft value.
`(package private) static class`	`LocalCache.WeightedStrongValueReference<K,V>`	References a strong value.
`(package private) static class`	`LocalCache.WeightedWeakValueReference<K,V>`	References a weak value.
`(package private) static class`	`LocalCache.WriteQueue<K,V>`	A custom queue for managing eviction order.
`(package private) class`	`LocalCache.WriteThroughEntry`	Custom Entry class used by EntryIterator.next(), that relays setValue changes to the underlying map.

Nested classes/interfaces inherited from class java.util.AbstractMap
java.util.AbstractMap.SimpleEntry<K extends java.lang.Object,V extends java.lang.Object>, java.util.AbstractMap.SimpleImmutableEntry<K extends java.lang.Object,V extends java.lang.Object>

Nested classes/interfaces inherited from interface java.util.Map
java.util.Map.Entry<K extends java.lang.Object,V extends java.lang.Object>

Field Summary

Fields
Modifier and Type	Field	Description
`(package private) int`	`concurrencyLevel`	The concurrency level.
`(package private) static int`	`CONTAINS_VALUE_RETRIES`	Number of (unsynchronized) retries in the containsValue method.
`(package private) CacheLoader<? super K,V>`	`defaultLoader`	The default cache loader to use on loading operations.
`(package private) static java.util.Queue<?>`	`DISCARDING_QUEUE`
`(package private) static int`	`DRAIN_MAX`	Maximum number of entries to be drained in a single cleanup run.
`(package private) static int`	`DRAIN_THRESHOLD`	Number of cache access operations that can be buffered per segment before the cache's recency ordering information is updated.
`(package private) LocalCache.EntryFactory`	`entryFactory`	Factory used to create new entries.
`(package private) java.util.Set<java.util.Map.Entry<K,V>>`	`entrySet`
`(package private) long`	`expireAfterAccessNanos`	How long after the last access to an entry the map will retain that entry.
`(package private) long`	`expireAfterWriteNanos`	How long after the last write to an entry the map will retain that entry.
`(package private) AbstractCache.StatsCounter`	`globalStatsCounter`	Accumulates global cache statistics.
`(package private) Equivalence<java.lang.Object>`	`keyEquivalence`	Strategy for comparing keys.
`(package private) java.util.Set<K>`	`keySet`
`(package private) LocalCache.Strength`	`keyStrength`	Strategy for referencing keys.
`(package private) static java.util.logging.Logger`	`logger`
`(package private) static int`	`MAX_SEGMENTS`	The maximum number of segments to allow; used to bound constructor arguments.
`(package private) static int`	`MAXIMUM_CAPACITY`	The maximum capacity, used if a higher value is implicitly specified by either of the constructors with arguments.
`(package private) long`	`maxWeight`	The maximum weight of this map.
`(package private) long`	`refreshNanos`	How long after the last write an entry becomes a candidate for refresh.
`(package private) RemovalListener<K,V>`	`removalListener`	A listener that is invoked when an entry is removed due to expiration or garbage collection of soft/weak entries.
`(package private) java.util.Queue<RemovalNotification<K,V>>`	`removalNotificationQueue`	Entries waiting to be consumed by the removal listener.
`(package private) int`	`segmentMask`	Mask value for indexing into segments.
`(package private) LocalCache.Segment<K,V>[]`	`segments`	The segments, each of which is a specialized hash table.
`(package private) int`	`segmentShift`	Shift value for indexing within segments.
`(package private) Ticker`	`ticker`	Measures time in a testable way.
`(package private) static LocalCache.ValueReference<java.lang.Object,java.lang.Object>`	`UNSET`	Placeholder.
`(package private) Equivalence<java.lang.Object>`	`valueEquivalence`	Strategy for comparing values.
`(package private) java.util.Collection<V>`	`values`
`(package private) LocalCache.Strength`	`valueStrength`	Strategy for referencing values.
`(package private) Weigher<K,V>`	`weigher`	Weigher to weigh cache entries.

Constructor Summary

Constructors
Constructor	Description
`LocalCache(CacheBuilder<? super K,? super V> builder, CacheLoader<? super K,V> loader)`	Creates a new, empty map with the specified strategy, initial capacity and concurrency level.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`cleanUp()`
`void`	`clear()`
`V`	`compute(K key, java.util.function.BiFunction<? super K,? super V,? extends V> function)`
`V`	`computeIfAbsent(K key, java.util.function.Function<? super K,? extends V> function)`
`V`	`computeIfPresent(K key, java.util.function.BiFunction<? super K,? super V,? extends V> function)`
`(package private) static <K,V> void`	`connectAccessOrder(ReferenceEntry<K,V> previous, ReferenceEntry<K,V> next)`
`(package private) static <K,V> void`	`connectWriteOrder(ReferenceEntry<K,V> previous, ReferenceEntry<K,V> next)`
`boolean`	`containsKey(java.lang.Object key)`
`boolean`	`containsValue(java.lang.Object value)`
`(package private) ReferenceEntry<K,V>`	`copyEntry(ReferenceEntry<K,V> original, ReferenceEntry<K,V> newNext)`	This method is a convenience for testing.
`(package private) LocalCache.Segment<K,V>`	`createSegment(int initialCapacity, long maxSegmentWeight, AbstractCache.StatsCounter statsCounter)`
`(package private) boolean`	`customWeigher()`
`(package private) static <E> java.util.Queue<E>`	`discardingQueue()`	Queue that discards all elements.
`java.util.Set<java.util.Map.Entry<K,V>>`	`entrySet()`
`(package private) boolean`	`evictsBySize()`
`(package private) boolean`	`expires()`
`(package private) boolean`	`expiresAfterAccess()`
`(package private) boolean`	`expiresAfterWrite()`
`V`	`get(java.lang.Object key)`
`(package private) V`	`get(K key, CacheLoader<? super K,V> loader)`
`(package private) ImmutableMap<K,V>`	`getAll(java.lang.Iterable<? extends K> keys)`
`(package private) ImmutableMap<K,V>`	`getAllPresent(java.lang.Iterable<?> keys)`
`(package private) ReferenceEntry<K,V>`	`getEntry(java.lang.Object key)`	Returns the internal entry for the specified key.
`V`	`getIfPresent(java.lang.Object key)`
`(package private) V`	`getLiveValue(ReferenceEntry<K,V> entry, long now)`	Gets the value from an entry.
`V`	`getOrDefault(java.lang.Object key, V defaultValue)`
`(package private) V`	`getOrLoad(K key)`
`(package private) int`	`hash(java.lang.Object key)`
`(package private) void`	`invalidateAll(java.lang.Iterable<?> keys)`
`boolean`	`isEmpty()`
`(package private) boolean`	`isExpired(ReferenceEntry<K,V> entry, long now)`	Returns true if the entry has expired.
`(package private) boolean`	`isLive(ReferenceEntry<K,V> entry, long now)`	This method is a convenience for testing.
`java.util.Set<K>`	`keySet()`
`(package private) java.util.Map<K,V>`	`loadAll(java.util.Set<? extends K> keys, CacheLoader<? super K,V> loader)`	Returns the result of calling `CacheLoader.loadAll(java.lang.Iterable<? extends K>)`, or null if `loader` doesn't implement `loadAll`.
`(package private) long`	`longSize()`
`V`	`merge(K key, V newValue, java.util.function.BiFunction<? super V,? super V,? extends V> function)`
`(package private) ReferenceEntry<K,V>`	`newEntry(K key, int hash, ReferenceEntry<K,V> next)`	This method is a convenience for testing.
`(package private) LocalCache.Segment<K,V>[]`	`newSegmentArray(int ssize)`
`(package private) LocalCache.ValueReference<K,V>`	`newValueReference(ReferenceEntry<K,V> entry, V value, int weight)`	This method is a convenience for testing.
`(package private) static <K,V> ReferenceEntry<K,V>`	`nullEntry()`
`(package private) static <K,V> void`	`nullifyAccessOrder(ReferenceEntry<K,V> nulled)`
`(package private) static <K,V> void`	`nullifyWriteOrder(ReferenceEntry<K,V> nulled)`
`(package private) void`	`processPendingNotifications()`	Notifies listeners that an entry has been automatically removed due to expiration, eviction, or eligibility for garbage collection.
`V`	`put(K key, V value)`
`void`	`putAll(java.util.Map<? extends K,? extends V> m)`
`V`	`putIfAbsent(K key, V value)`
`(package private) void`	`reclaimKey(ReferenceEntry<K,V> entry)`
`(package private) void`	`reclaimValue(LocalCache.ValueReference<K,V> valueReference)`
`(package private) boolean`	`recordsAccess()`
`(package private) boolean`	`recordsTime()`
`(package private) boolean`	`recordsWrite()`
`(package private) void`	`refresh(K key)`
`(package private) boolean`	`refreshes()`
`(package private) static int`	`rehash(int h)`	Applies a supplemental hash function to a given hash code, which defends against poor quality hash functions.
`V`	`remove(java.lang.Object key)`
`boolean`	`remove(java.lang.Object key, java.lang.Object value)`
`(package private) boolean`	`removeIf(java.util.function.BiPredicate<? super K,? super V> filter)`
`V`	`replace(K key, V value)`
`boolean`	`replace(K key, V oldValue, V newValue)`
`(package private) LocalCache.Segment<K,V>`	`segmentFor(int hash)`	Returns the segment that should be used for a key with the given hash.
`int`	`size()`
`private static <E> java.util.ArrayList<E>`	`toArrayList(java.util.Collection<E> c)`
`(package private) static <K,V> LocalCache.ValueReference<K,V>`	`unset()`	Singleton placeholder that indicates a value is being loaded.
`(package private) boolean`	`usesAccessEntries()`
`(package private) boolean`	`usesAccessQueue()`
`(package private) boolean`	`usesKeyReferences()`
`(package private) boolean`	`usesValueReferences()`
`(package private) boolean`	`usesWriteEntries()`
`(package private) boolean`	`usesWriteQueue()`
`java.util.Collection<V>`	`values()`

Methods inherited from class java.util.AbstractMap
clone, equals, hashCode, toString

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.concurrent.ConcurrentMap
forEach, replaceAll

Methods inherited from interface java.util.Map
equals, hashCode

- Field Detail
  - MAXIMUM_CAPACITY
```
static final int MAXIMUM_CAPACITY
```
    The maximum capacity, used if a higher value is implicitly specified by either of the constructors with arguments. MUST be a power of two <= 1<<30 to ensure that entries are indexable using ints.
    
    See Also:
    
    Constant Field Values
  - MAX_SEGMENTS
```
static final int MAX_SEGMENTS
```
    The maximum number of segments to allow; used to bound constructor arguments.
    
    See Also:
    
    Constant Field Values
  - CONTAINS_VALUE_RETRIES
```
static final int CONTAINS_VALUE_RETRIES
```
    Number of (unsynchronized) retries in the containsValue method.
    
    See Also:
    
    Constant Field Values
  - DRAIN_THRESHOLD
```
static final int DRAIN_THRESHOLD
```
    Number of cache access operations that can be buffered per segment before the cache's recency ordering information is updated. This is used to avoid lock contention by recording a memento of reads and delaying a lock acquisition until the threshold is crossed or a mutation occurs.
    This must be a (2^n)-1 as it is used as a mask.
    
    See Also:
    
    Constant Field Values
  - DRAIN_MAX
```
static final int DRAIN_MAX
```
    Maximum number of entries to be drained in a single cleanup run. This applies independently to the cleanup queue and both reference queues.
    
    See Also:
    
    Constant Field Values
  - logger
```
static final java.util.logging.Logger logger
```
  - segmentMask
```
final int segmentMask
```
    Mask value for indexing into segments. The upper bits of a key's hash code are used to choose the segment.
  - segmentShift
```
final int segmentShift
```
    Shift value for indexing within segments. Helps prevent entries that end up in the same segment from also ending up in the same bucket.
  - segments
```
final LocalCache.Segment<K,V>[] segments
```
    The segments, each of which is a specialized hash table.
  - concurrencyLevel
```
final int concurrencyLevel
```
    The concurrency level.
  - keyEquivalence
```
final Equivalence<java.lang.Object> keyEquivalence
```
    Strategy for comparing keys.
  - valueEquivalence
```
final Equivalence<java.lang.Object> valueEquivalence
```
    Strategy for comparing values.
  - keyStrength
```
final LocalCache.Strength keyStrength
```
    Strategy for referencing keys.
  - valueStrength
```
final LocalCache.Strength valueStrength
```
    Strategy for referencing values.
  - maxWeight
```
final long maxWeight
```
    The maximum weight of this map. UNSET_INT if there is no maximum.
  - weigher
```
final Weigher<K,V> weigher
```
    Weigher to weigh cache entries.
  - expireAfterAccessNanos
```
final long expireAfterAccessNanos
```
    How long after the last access to an entry the map will retain that entry.
  - expireAfterWriteNanos
```
final long expireAfterWriteNanos
```
    How long after the last write to an entry the map will retain that entry.
  - refreshNanos
```
final long refreshNanos
```
    How long after the last write an entry becomes a candidate for refresh.
  - removalNotificationQueue
```
final java.util.Queue<RemovalNotification<K,V>> removalNotificationQueue
```
    Entries waiting to be consumed by the removal listener.
  - removalListener
```
final RemovalListener<K,V> removalListener
```
    A listener that is invoked when an entry is removed due to expiration or garbage collection of soft/weak entries.
  - ticker
```
final Ticker ticker
```
    Measures time in a testable way.
  - entryFactory
```
final LocalCache.EntryFactory entryFactory
```
    Factory used to create new entries.
  - globalStatsCounter
```
final AbstractCache.StatsCounter globalStatsCounter
```
    Accumulates global cache statistics. Note that there are also per-segments stats counters which must be aggregated to obtain a global stats view.
  - defaultLoader
```
final CacheLoader<? super K,V> defaultLoader
```
    The default cache loader to use on loading operations.
  - UNSET
```
static final LocalCache.ValueReference<java.lang.Object,java.lang.Object> UNSET
```
    Placeholder. Indicates that the value hasn't been set yet.
  - DISCARDING_QUEUE
```
static final java.util.Queue<?> DISCARDING_QUEUE
```
  - keySet
```
java.util.Set<K> keySet
```
  - values
```
java.util.Collection<V> values
```
  - entrySet
```
java.util.Set<java.util.Map.Entry<K,V>> entrySet
```
- Constructor Detail
  - LocalCache
```
LocalCache(CacheBuilder<? super K,? super V> builder,
           CacheLoader<? super K,V> loader)
```
    Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
- Method Detail
  - evictsBySize
```
boolean evictsBySize()
```
  - customWeigher
```
boolean customWeigher()
```
  - expires
```
boolean expires()
```
  - expiresAfterWrite
```
boolean expiresAfterWrite()
```
  - expiresAfterAccess
```
boolean expiresAfterAccess()
```
  - refreshes
```
boolean refreshes()
```
  - usesAccessQueue
```
boolean usesAccessQueue()
```
  - usesWriteQueue
```
boolean usesWriteQueue()
```
  - recordsWrite
```
boolean recordsWrite()
```
  - recordsAccess
```
boolean recordsAccess()
```
  - recordsTime
```
boolean recordsTime()
```
  - usesWriteEntries
```
boolean usesWriteEntries()
```
  - usesAccessEntries
```
boolean usesAccessEntries()
```
  - usesKeyReferences
```
boolean usesKeyReferences()
```
  - usesValueReferences
```
boolean usesValueReferences()
```
  - unset
```
static <K,V> LocalCache.ValueReference<K,V> unset()
```
    Singleton placeholder that indicates a value is being loaded.
  - nullEntry
```
static <K,V> ReferenceEntry<K,V> nullEntry()
```
  - discardingQueue
```
static <E> java.util.Queue<E> discardingQueue()
```
    Queue that discards all elements.
  - rehash
```
static int rehash(int h)
```
    Applies a supplemental hash function to a given hash code, which defends against poor quality hash functions. This is critical when the concurrent hash map uses power-of-two length hash tables, that otherwise encounter collisions for hash codes that do not differ in lower or upper bits.
    
    Parameters:
    
    h - hash code
  - newEntry
```
ReferenceEntry<K,V> newEntry(K key,
                                   int hash,
                                   ReferenceEntry<K,V> next)
```
    This method is a convenience for testing. Code should call LocalCache.Segment.newEntry(K, int, com.google.common.cache.ReferenceEntry<K, V>) directly.
  - copyEntry
```
ReferenceEntry<K,V> copyEntry(ReferenceEntry<K,V> original,
                                    ReferenceEntry<K,V> newNext)
```
    This method is a convenience for testing. Code should call LocalCache.Segment.copyEntry(com.google.common.cache.ReferenceEntry<K, V>, com.google.common.cache.ReferenceEntry<K, V>) directly.
  - newValueReference
```
LocalCache.ValueReference<K,V> newValueReference(ReferenceEntry<K,V> entry,
                                                       V value,
                                                       int weight)
```
    This method is a convenience for testing. Code should call LocalCache.Segment.setValue(com.google.common.cache.ReferenceEntry<K, V>, K, V, long) instead.
  - hash
```
int hash(java.lang.Object key)
```
  - reclaimValue
```
void reclaimValue(LocalCache.ValueReference<K,V> valueReference)
```
  - reclaimKey
```
void reclaimKey(ReferenceEntry<K,V> entry)
```
  - isLive
```
boolean isLive(ReferenceEntry<K,V> entry,
               long now)
```
    This method is a convenience for testing. Code should call LocalCache.Segment.getLiveValue(com.google.common.cache.ReferenceEntry<K, V>, long) instead.
  - segmentFor
```
LocalCache.Segment<K,V> segmentFor(int hash)
```
    Returns the segment that should be used for a key with the given hash.
    
    Parameters:
    
    hash - the hash code for the key
    
    Returns:
    
    the segment
  - createSegment
```
LocalCache.Segment<K,V> createSegment(int initialCapacity,
                                            long maxSegmentWeight,
                                            AbstractCache.StatsCounter statsCounter)
```
  - getLiveValue
```
V getLiveValue(ReferenceEntry<K,V> entry,
               long now)
```
    Gets the value from an entry. Returns null if the entry is invalid, partially-collected, loading, or expired. Unlike LocalCache.Segment.getLiveValue(com.google.common.cache.ReferenceEntry<K, V>, long) this method does not attempt to cleanup stale entries. As such it should only be called outside of a segment context, such as during iteration.
  - isExpired
```
boolean isExpired(ReferenceEntry<K,V> entry,
                  long now)
```
    Returns true if the entry has expired.
  - connectAccessOrder
```
static <K,V> void connectAccessOrder(ReferenceEntry<K,V> previous,
                                           ReferenceEntry<K,V> next)
```
  - nullifyAccessOrder
```
static <K,V> void nullifyAccessOrder(ReferenceEntry<K,V> nulled)
```
  - connectWriteOrder
```
static <K,V> void connectWriteOrder(ReferenceEntry<K,V> previous,
                                          ReferenceEntry<K,V> next)
```
  - nullifyWriteOrder
```
static <K,V> void nullifyWriteOrder(ReferenceEntry<K,V> nulled)
```
  - processPendingNotifications
```
void processPendingNotifications()
```
    Notifies listeners that an entry has been automatically removed due to expiration, eviction, or eligibility for garbage collection. This should be called every time expireEntries or evictEntry is called (once the lock is released).
  - newSegmentArray
```
final LocalCache.Segment<K,V>[] newSegmentArray(int ssize)
```
  - cleanUp
```
public void cleanUp()
```
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Map<K,V>
    
    Overrides:
    
    isEmpty in class java.util.AbstractMap<K,V>
  - longSize
```
long longSize()
```
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Map<K,V>
    
    Overrides:
    
    size in class java.util.AbstractMap<K,V>
  - get
```
public V get(java.lang.Object key)
```
    Specified by:
    
    get in interface java.util.Map<K,V>
    
    Overrides:
    
    get in class java.util.AbstractMap<K,V>
  - get
```
V get(K key,
      CacheLoader<? super K,V> loader)
throws java.util.concurrent.ExecutionException
```
    Throws:
    
    java.util.concurrent.ExecutionException
  - getIfPresent
```
public V getIfPresent(java.lang.Object key)
```
  - getOrDefault
```
public V getOrDefault(java.lang.Object key,
                      V defaultValue)
```
    Specified by:
    
    getOrDefault in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    getOrDefault in interface java.util.Map<K,V>
  - getOrLoad
```
V getOrLoad(K key)
     throws java.util.concurrent.ExecutionException
```
    Throws:
    
    java.util.concurrent.ExecutionException
  - getAllPresent
```
ImmutableMap<K,V> getAllPresent(java.lang.Iterable<?> keys)
```
  - getAll
```
ImmutableMap<K,V> getAll(java.lang.Iterable<? extends K> keys)
                        throws java.util.concurrent.ExecutionException
```
    Throws:
    
    java.util.concurrent.ExecutionException
  - loadAll
```
java.util.Map<K,V> loadAll(java.util.Set<? extends K> keys,
                                 CacheLoader<? super K,V> loader)
                          throws java.util.concurrent.ExecutionException
```
    Returns the result of calling CacheLoader.loadAll(java.lang.Iterable<? extends K>), or null if loader doesn't implement loadAll.
    
    Throws:
    
    java.util.concurrent.ExecutionException
  - getEntry
```
ReferenceEntry<K,V> getEntry(java.lang.Object key)
```
    Returns the internal entry for the specified key. The entry may be loading, expired, or partially collected.
  - refresh
```
void refresh(K key)
```
  - containsKey
```
public boolean containsKey(java.lang.Object key)
```
    Specified by:
    
    containsKey in interface java.util.Map<K,V>
    
    Overrides:
    
    containsKey in class java.util.AbstractMap<K,V>
  - containsValue
```
public boolean containsValue(java.lang.Object value)
```
    Specified by:
    
    containsValue in interface java.util.Map<K,V>
    
    Overrides:
    
    containsValue in class java.util.AbstractMap<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface java.util.Map<K,V>
    
    Overrides:
    
    put in class java.util.AbstractMap<K,V>
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    Specified by:
    
    putIfAbsent in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface java.util.Map<K,V>
  - compute
```
public V compute(K key,
                 java.util.function.BiFunction<? super K,? super V,? extends V> function)
```
    Specified by:
    
    compute in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    compute in interface java.util.Map<K,V>
  - computeIfAbsent
```
public V computeIfAbsent(K key,
                         java.util.function.Function<? super K,? extends V> function)
```
    Specified by:
    
    computeIfAbsent in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    computeIfAbsent in interface java.util.Map<K,V>
  - computeIfPresent
```
public V computeIfPresent(K key,
                          java.util.function.BiFunction<? super K,? super V,? extends V> function)
```
    Specified by:
    
    computeIfPresent in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    computeIfPresent in interface java.util.Map<K,V>
  - merge
```
public V merge(K key,
               V newValue,
               java.util.function.BiFunction<? super V,? super V,? extends V> function)
```
    Specified by:
    
    merge in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    merge in interface java.util.Map<K,V>
  - putAll
```
public void putAll(java.util.Map<? extends K,? extends V> m)
```
    Specified by:
    
    putAll in interface java.util.Map<K,V>
    
    Overrides:
    
    putAll in class java.util.AbstractMap<K,V>
  - remove
```
public V remove(java.lang.Object key)
```
    Specified by:
    
    remove in interface java.util.Map<K,V>
    
    Overrides:
    
    remove in class java.util.AbstractMap<K,V>
  - remove
```
public boolean remove(java.lang.Object key,
                      java.lang.Object value)
```
    Specified by:
    
    remove in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    remove in interface java.util.Map<K,V>
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    Specified by:
    
    replace in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface java.util.Map<K,V>
  - replace
```
public V replace(K key,
                 V value)
```
    Specified by:
    
    replace in interface java.util.concurrent.ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface java.util.Map<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Map<K,V>
    
    Overrides:
    
    clear in class java.util.AbstractMap<K,V>
  - invalidateAll
```
void invalidateAll(java.lang.Iterable<?> keys)
```
  - keySet
```
public java.util.Set<K> keySet()
```
    Specified by:
    
    keySet in interface java.util.Map<K,V>
    
    Overrides:
    
    keySet in class java.util.AbstractMap<K,V>
  - values
```
public java.util.Collection<V> values()
```
    Specified by:
    
    values in interface java.util.Map<K,V>
    
    Overrides:
    
    values in class java.util.AbstractMap<K,V>
  - entrySet
```
public java.util.Set<java.util.Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface java.util.Map<K,V>
    
    Specified by:
    
    entrySet in class java.util.AbstractMap<K,V>
  - toArrayList
```
private static <E> java.util.ArrayList<E> toArrayList(java.util.Collection<E> c)
```
  - removeIf
```
boolean removeIf(java.util.function.BiPredicate<? super K,? super V> filter)
```

Class LocalCache<K,​V>

Nested Class Summary

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

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractMap

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.ConcurrentMap

Methods inherited from interface java.util.Map

Field Detail

MAXIMUM_CAPACITY

MAX_SEGMENTS

CONTAINS_VALUE_RETRIES

DRAIN_THRESHOLD

DRAIN_MAX

logger

segmentMask

segmentShift

segments

concurrencyLevel

keyEquivalence

valueEquivalence

keyStrength

valueStrength

maxWeight

weigher

expireAfterAccessNanos

expireAfterWriteNanos

refreshNanos

removalNotificationQueue

removalListener

ticker

entryFactory

globalStatsCounter

defaultLoader

UNSET

DISCARDING_QUEUE

keySet

values

entrySet

Constructor Detail

LocalCache

Method Detail

evictsBySize

customWeigher

expires

expiresAfterWrite

expiresAfterAccess

refreshes

usesAccessQueue

usesWriteQueue

recordsWrite

recordsAccess

recordsTime

usesWriteEntries

usesAccessEntries

usesKeyReferences

usesValueReferences

unset

nullEntry

discardingQueue

rehash

newEntry

copyEntry

newValueReference

hash

reclaimValue

reclaimKey

isLive

segmentFor

createSegment

getLiveValue

isExpired

connectAccessOrder

nullifyAccessOrder

connectWriteOrder

nullifyWriteOrder

processPendingNotifications

Class LocalCache<K,V>