ReferenceConcurrentMap (hutool 5.8.32 API)

java.lang.Object
- cn.hutool.core.map.ReferenceConcurrentMap<K,V>

Type Parameters:

K - 键类型

V - 值类型

All Implemented Interfaces:

Serializable, Iterable<Map.Entry<K,V>>, ConcurrentMap<K,V>, Map<K,V>

Direct Known Subclasses:

WeakConcurrentMap
```
public class ReferenceConcurrentMap<K,V>
extends Object
implements ConcurrentMap<K,V>, Iterable<Map.Entry<K,V>>, Serializable
```
线程安全的ReferenceMap实现
参考：jdk.management.resource.internal.WeakKeyConcurrentHashMap

Since:

5.8.0

Author:

looly

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Constructor Summary

Constructors
Constructor and Description

ReferenceConcurrentMap(ConcurrentMap<Reference<K>,V> raw, ReferenceUtil.ReferenceType referenceType)
构造

Constructors
Constructor and Description
`ReferenceConcurrentMap(ConcurrentMap<Reference<K>,V> raw, ReferenceUtil.ReferenceType referenceType)` 构造

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`V`	`compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`
`V`	`computeIfAbsent(K key, Func0<? extends V> supplier)` 从缓存中获得对象，当对象不在缓存中或已经过期返回Func0回调产生的对象
`V`	`computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)`
`V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Set<Map.Entry<K,V>>`	`entrySet()`
`void`	`forEach(BiConsumer<? super K,? super V> action)`
`V`	`get(Object key)`
`boolean`	`isEmpty()`
`Iterator<Map.Entry<K,V>>`	`iterator()`
`Set<K>`	`keySet()`
`V`	`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)`
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> m)`
`V`	`putIfAbsent(K key, V value)`
`V`	`remove(Object key)`
`boolean`	`remove(Object key, Object value)`
`V`	`replace(K key, V value)`
`boolean`	`replace(K key, V oldValue, V newValue)`
`void`	`replaceAll(BiFunction<? super K,? super V,? extends V> function)`
`void`	`setPurgeListener(BiConsumer<Reference<? extends K>,V> purgeListener)` 设置对象回收清除监听
`int`	`size()`
`Collection<V>`	`values()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.concurrent.ConcurrentMap
getOrDefault

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - ReferenceConcurrentMap
```
public ReferenceConcurrentMap(ConcurrentMap<Reference<K>,V> raw,
                              ReferenceUtil.ReferenceType referenceType)
```
    构造
    
    Parameters:
    
    raw - ConcurrentMap实现
    
    referenceType - Reference类型
- Method Detail
  - setPurgeListener
```
public void setPurgeListener(BiConsumer<Reference<? extends K>,V> purgeListener)
```
    设置对象回收清除监听
    
    Parameters:
    
    purgeListener - 监听函数
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<K,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get 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>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface Map<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> m)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - replace
```
public V replace(K key,
                 V value)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - replaceAll
```
public void replaceAll(BiFunction<? super K,? super V,? extends V> function)
```
    Specified by:
    
    replaceAll in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replaceAll in interface Map<K,V>
  - computeIfAbsent
```
public V computeIfAbsent(K key,
                         Function<? super K,? extends V> mappingFunction)
```
    Specified by:
    
    computeIfAbsent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    computeIfAbsent in interface Map<K,V>
  - computeIfPresent
```
public V computeIfPresent(K key,
                          BiFunction<? super K,? super V,? extends V> remappingFunction)
```
    Specified by:
    
    computeIfPresent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    computeIfPresent in interface Map<K,V>
  - computeIfAbsent
```
public V computeIfAbsent(K key,
                         Func0<? extends V> supplier)
```
    从缓存中获得对象，当对象不在缓存中或已经过期返回Func0回调产生的对象
    
    Parameters:
    
    key - 键
    
    supplier - 如果不存在回调方法，用于生产值对象
    
    Returns:
    
    值对象
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Specified by:
    
    remove in interface ConcurrentMap<K,V>
    
    Specified by:
    
    remove in interface Map<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - keySet
```
public Set<K> keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>
  - forEach
```
public void forEach(BiConsumer<? super K,? super V> action)
```
    Specified by:
    
    forEach in interface ConcurrentMap<K,V>
    
    Specified by:
    
    forEach in interface Map<K,V>
  - iterator
```
public Iterator<Map.Entry<K,V>> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Map.Entry<K,V>>
  - compute
```
public V compute(K key,
                 BiFunction<? super K,? super V,? extends V> remappingFunction)
```
    Specified by:
    
    compute in interface ConcurrentMap<K,V>
    
    Specified by:
    
    compute in interface Map<K,V>
  - merge
```
public V merge(K key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)
```
    Specified by:
    
    merge in interface ConcurrentMap<K,V>
    
    Specified by:
    
    merge in interface Map<K,V>

Class ReferenceConcurrentMap<K,V>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.ConcurrentMap

Methods inherited from interface java.util.Map

Methods inherited from interface java.lang.Iterable

Constructor Detail

ReferenceConcurrentMap

Method Detail

setPurgeListener

size

isEmpty

get

containsKey

containsValue

put

putIfAbsent

putAll

replace

replace

replaceAll

computeIfAbsent

computeIfPresent

computeIfAbsent

remove

remove

clear

keySet

values

entrySet

forEach

iterator

compute

merge