K
- keyV
- valuepublic class RedissonMap<K,V> extends RedissonObject implements RMap<K,V>
ConcurrentMap
and Map
codec, commandExecutor, name
Constructor and Description |
---|
RedissonMap(Codec codec,
CommandAsyncExecutor commandExecutor,
String name,
RedissonClient redisson,
MapOptions<K,V> options,
WriteBehindService writeBehindService) |
RedissonMap(CommandAsyncExecutor commandExecutor,
String name,
RedissonClient redisson,
MapOptions<K,V> options,
WriteBehindService writeBehindService) |
Modifier and Type | Method and Description |
---|---|
V |
addAndGet(K key,
Number value)
Adds the given
delta to the current value
by mapped key . |
RFuture<V> |
addAndGetAsync(K key,
Number value)
Adds the given
delta to the current value
by mapped key . |
protected RFuture<V> |
addAndGetOperationAsync(K key,
Number value) |
protected void |
checkKey(Object key) |
protected void |
checkValue(Object value) |
void |
clear() |
boolean |
clearExpire()
Clear an expire timeout or expire date for object.
|
RFuture<Boolean> |
clearExpireAsync()
Clear an expire timeout or expire date for object in async mode.
|
protected RFuture<Boolean> |
clearExpireAsync(String... keys) |
boolean |
containsKey(Object key)
Returns
true if this map contains map entry
mapped by specified key , otherwise false |
RFuture<Boolean> |
containsKeyAsync(Object key)
Returns
true if this map contains map entry
mapped by specified key , otherwise false |
boolean |
containsValue(Object value)
Returns
true if this map contains any map entry
with specified value , otherwise false |
RFuture<Boolean> |
containsValueAsync(Object value)
Returns
true if this map contains any map entry
with specified value , otherwise false |
protected Iterator<Map.Entry<K,V>> |
entryIterator(String pattern,
int count) |
Set<Map.Entry<K,V>> |
entrySet()
Returns map entries collection.
|
Set<Map.Entry<K,V>> |
entrySet(int count)
Returns map entries collection.
|
Set<Map.Entry<K,V>> |
entrySet(String keyPattern)
Returns map entries collection.
|
Set<Map.Entry<K,V>> |
entrySet(String keyPattern,
int count)
Returns map entries collection.
|
boolean |
equals(Object o) |
boolean |
expire(long timeToLive,
TimeUnit timeUnit)
Set a timeout for object.
|
RFuture<Boolean> |
expireAsync(long timeToLive,
TimeUnit timeUnit)
Set a timeout for object in async mode.
|
protected RFuture<Boolean> |
expireAsync(long timeToLive,
TimeUnit timeUnit,
String... keys) |
boolean |
expireAt(Date timestamp)
Set an expire date for object.
|
boolean |
expireAt(long timestamp)
Set an expire date for object.
|
RFuture<Boolean> |
expireAtAsync(Date timestamp)
Set an expire date for object in async mode.
|
RFuture<Boolean> |
expireAtAsync(long timestamp)
Set an expire date for object in async mode.
|
protected RFuture<Boolean> |
expireAtAsync(long timestamp,
String... keys) |
boolean |
fastPut(K key,
V value)
Stores the specified
value mapped by specified key . |
RFuture<Boolean> |
fastPutAsync(K key,
V value)
Stores the specified
value mapped by specified key . |
boolean |
fastPutIfAbsent(K key,
V value)
Stores the specified
value mapped by specified key
only if there is no value with specifiedkey stored before. |
RFuture<Boolean> |
fastPutIfAbsentAsync(K key,
V value)
Stores the specified
value mapped by specified key
only if there is no value with specifiedkey stored before. |
protected RFuture<Boolean> |
fastPutIfAbsentOperationAsync(K key,
V value) |
protected RFuture<Boolean> |
fastPutOperationAsync(K key,
V value) |
long |
fastRemove(K... keys)
Removes map entries mapped by specified
keys . |
RFuture<Long> |
fastRemoveAsync(K... keys)
Removes map entries mapped by specified
keys . |
protected RFuture<Long> |
fastRemoveOperationAsync(K... keys) |
protected RFuture<List<Long>> |
fastRemoveOperationBatchAsync(K... keys) |
boolean |
fastReplace(K key,
V value)
Replaces previous value with a new
value mapped by specified key . |
RFuture<Boolean> |
fastReplaceAsync(K key,
V value)
Replaces previous value with a new
value mapped by specified key . |
protected RFuture<Boolean> |
fastReplaceOperationAsync(K key,
V value) |
V |
get(Object key)
Returns the value mapped by defined
key or null if value is absent. |
Map<K,V> |
getAll(Set<K> keys)
Returns map slice contained the mappings with defined
keys . |
RFuture<Map<K,V>> |
getAllAsync(Set<K> keys)
Returns map slice contained the mappings with defined
keys . |
RFuture<Map<K,V>> |
getAllOperationAsync(Set<K> keys) |
RFuture<V> |
getAsync(K key)
Returns the value mapped by defined
key or null if value is absent. |
RCountDownLatch |
getCountDownLatch(K key)
Returns
RCountDownLatch instance associated with key |
RLock |
getFairLock(K key)
Returns
RLock instance associated with key |
RLock |
getLock(K key)
Returns
RLock instance associated with key |
RFuture<V> |
getOperationAsync(K key) |
RPermitExpirableSemaphore |
getPermitExpirableSemaphore(K key)
Returns
RPermitExpirableSemaphore instance associated with key |
RReadWriteLock |
getReadWriteLock(K key)
Returns
RReadWriteLock instance associated with key |
RSemaphore |
getSemaphore(K key)
Returns
RSemaphore instance associated with key |
int |
hashCode() |
protected boolean |
hasNoLoader() |
protected boolean |
hasNoWriter() |
boolean |
isEmpty() |
protected Iterator<K> |
keyIterator(String pattern,
int count) |
Set<K> |
keySet()
Returns key set of this map.
|
Set<K> |
keySet(int count)
Returns key set of this map.
|
Set<K> |
keySet(String pattern)
Returns key set of this map.
|
Set<K> |
keySet(String pattern,
int count)
Returns key set of this map.
|
void |
loadAll(boolean replaceExistingValues,
int parallelism)
Loads all map entries to this Redis map using
MapLoader . |
void |
loadAll(Set<? extends K> keys,
boolean replaceExistingValues,
int parallelism)
Loads map entries using
MapLoader whose keys are listed in defined keys parameter. |
RFuture<Void> |
loadAllAsync(boolean replaceExistingValues,
int parallelism)
Loads all map entries to this Redis map using
MapLoader . |
RFuture<Void> |
loadAllAsync(Set<? extends K> keys,
boolean replaceExistingValues,
int parallelism)
Loads map entries using
MapLoader whose keys are listed in defined keys parameter. |
<KOut,VOut> |
mapReduce()
Returns
RMapReduce object associated with this map |
protected <M> RFuture<M> |
mapWriterFuture(RFuture<M> future,
MapWriterTask task) |
protected <M> RFuture<M> |
mapWriterFuture(RFuture<M> future,
MapWriterTask task,
Function<M,Boolean> condition) |
V |
put(K key,
V value)
Stores the specified
value mapped by specified key . |
void |
putAll(Map<? extends K,? extends V> map)
Stores map entries specified in
map object in batch mode. |
void |
putAll(Map<? extends K,? extends V> map,
int batchSize)
Stores map entries specified in
map object in batch mode. |
RFuture<Void> |
putAllAsync(Map<? extends K,? extends V> map)
Stores map entries specified in
map object in batch mode. |
RFuture<Void> |
putAllAsync(Map<? extends K,? extends V> map,
int batchSize)
Stores map entries specified in
map object in batch mode. |
protected RFuture<Void> |
putAllOperationAsync(Map<? extends K,? extends V> map) |
RFuture<V> |
putAsync(K key,
V value)
Stores the specified
value mapped by specified key . |
V |
putIfAbsent(K key,
V value)
Stores the specified
value mapped by specified key
only if there is no value with specifiedkey stored before. |
RFuture<V> |
putIfAbsentAsync(K key,
V value)
Stores the specified
value mapped by specified key
only if there is no value with specifiedkey stored before. |
protected RFuture<V> |
putIfAbsentOperationAsync(K key,
V value) |
protected RFuture<V> |
putOperationAsync(K key,
V value) |
Set<Map.Entry<K,V>> |
readAllEntrySet()
Read all map entries at once
|
RFuture<Set<Map.Entry<K,V>>> |
readAllEntrySetAsync()
Read all map entries at once
|
Set<K> |
readAllKeySet()
Read all keys at once
|
RFuture<Set<K>> |
readAllKeySetAsync()
Read all keys at once
|
Map<K,V> |
readAllMap()
Read all map as local instance at once
|
RFuture<Map<K,V>> |
readAllMapAsync()
Read all map as local instance at once
|
Collection<V> |
readAllValues()
Read all values at once
|
RFuture<Collection<V>> |
readAllValuesAsync()
Read all values at once
|
long |
remainTimeToLive()
Remaining time to live of Redisson object that has a timeout
|
RFuture<Long> |
remainTimeToLiveAsync()
Remaining time to live of Redisson object that has a timeout
|
V |
remove(Object key)
Removes map entry by specified
key and returns value. |
boolean |
remove(Object key,
Object value)
Removes map entry only if it exists with specified
key and value . |
RFuture<V> |
removeAsync(K key)
Removes map entry by specified
key and returns value. |
RFuture<Boolean> |
removeAsync(Object key,
Object value)
Removes map entry only if it exists with specified
key and value . |
protected RFuture<V> |
removeOperationAsync(K key) |
protected RFuture<Boolean> |
removeOperationAsync(Object key,
Object value) |
V |
replace(K key,
V value)
Replaces previous value with a new
value mapped by specified key . |
boolean |
replace(K key,
V oldValue,
V newValue)
Replaces previous
oldValue with a newValue mapped by specified key . |
RFuture<V> |
replaceAsync(K key,
V value)
Replaces previous value with a new
value mapped by specified key . |
RFuture<Boolean> |
replaceAsync(K key,
V oldValue,
V newValue)
Replaces previous
oldValue with a newValue mapped by specified key . |
protected RFuture<V> |
replaceOperationAsync(K key,
V value) |
protected RFuture<Boolean> |
replaceOperationAsync(K key,
V oldValue,
V newValue) |
MapScanResult<Object,Object> |
scanIterator(String name,
RedisClient client,
long startPos,
String pattern,
int count) |
RFuture<MapScanResult<Object,Object>> |
scanIteratorAsync(String name,
RedisClient client,
long startPos,
String pattern,
int count) |
int |
size() |
RFuture<Integer> |
sizeAsync()
Returns size of this map
|
protected Iterator<V> |
valueIterator(String pattern,
int count) |
Collection<V> |
values()
Returns values collection of this map.
|
Collection<V> |
values(int count)
Returns values collection of this map.
|
Collection<V> |
values(String keyPattern)
Returns values collection of this map.
|
Collection<V> |
values(String keyPattern,
int count)
Returns values collection of this map.
|
int |
valueSize(K key)
Returns size of value mapped by specified
key in bytes |
RFuture<Integer> |
valueSizeAsync(K key)
Returns size of value mapped by key in bytes
|
addListener, addListener, addListenerAsync, addListenerAsync, copy, copyAsync, delete, deleteAsync, deleteAsync, dump, dumpAsync, encode, encode, encode, encode, encodeMapKey, encodeMapKeys, encodeMapValue, encodeMapValues, get, getCodec, getLockByMapKey, getLockByValue, getName, getName, isExists, isExistsAsync, migrate, migrateAsync, move, moveAsync, prefixName, removeListener, removeListenerAsync, removeListenersAsync, rename, renameAsync, renamenx, renamenxAsync, restore, restore, restoreAndReplace, restoreAndReplace, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemory, sizeInMemoryAsync, sizeInMemoryAsync, suffixName, toSeconds, toStream, touch, touchAsync, unlink, unlinkAsync
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll
clearExpire, expire, expireAt, expireAt, remainTimeToLive
addListener, copy, delete, dump, getCodec, getName, isExists, migrate, move, removeListener, rename, renamenx, restore, restore, restoreAndReplace, restoreAndReplace, sizeInMemory, touch, unlink
clearExpireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsync
addListenerAsync, copyAsync, deleteAsync, dumpAsync, isExistsAsync, migrateAsync, moveAsync, removeListenerAsync, renameAsync, renamenxAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemoryAsync, touchAsync, unlinkAsync
public RedissonMap(CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K,V> options, WriteBehindService writeBehindService)
public RedissonMap(Codec codec, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K,V> options, WriteBehindService writeBehindService)
public <KOut,VOut> RMapReduce<K,V,KOut,VOut> mapReduce()
RMap
RMapReduce
object associated with this mappublic RPermitExpirableSemaphore getPermitExpirableSemaphore(K key)
RMap
RPermitExpirableSemaphore
instance associated with keygetPermitExpirableSemaphore
in interface RMap<K,V>
key
- - map keypublic RSemaphore getSemaphore(K key)
RMap
RSemaphore
instance associated with keygetSemaphore
in interface RMap<K,V>
key
- - map keypublic RCountDownLatch getCountDownLatch(K key)
RMap
RCountDownLatch
instance associated with keygetCountDownLatch
in interface RMap<K,V>
key
- - map keypublic RLock getFairLock(K key)
RMap
RLock
instance associated with keygetFairLock
in interface RMap<K,V>
key
- - map keypublic RLock getLock(K key)
RMap
RLock
instance associated with keypublic RReadWriteLock getReadWriteLock(K key)
RMap
RReadWriteLock
instance associated with keygetReadWriteLock
in interface RMap<K,V>
key
- - map keypublic RFuture<Integer> sizeAsync()
RMapAsync
public int valueSize(K key)
RMap
key
in bytespublic RFuture<Integer> valueSizeAsync(K key)
RMapAsync
valueSizeAsync
in interface RMapAsync<K,V>
key
- - map keyprotected void checkKey(Object key)
public boolean containsKey(Object key)
RMap
true
if this map contains map entry
mapped by specified key
, otherwise false
containsKey
in interface Map<K,V>
containsKey
in interface RMap<K,V>
key
- - map keytrue
if this map contains map entry
mapped by specified key
, otherwise false
public RFuture<Boolean> containsKeyAsync(Object key)
RMapAsync
true
if this map contains map entry
mapped by specified key
, otherwise false
containsKeyAsync
in interface RMapAsync<K,V>
key
- - map keytrue
if this map contains map entry
mapped by specified key
, otherwise false
public boolean containsValue(Object value)
RMap
true
if this map contains any map entry
with specified value
, otherwise false
containsValue
in interface Map<K,V>
containsValue
in interface RMap<K,V>
value
- - map valuetrue
if this map contains any map entry
with specified value
, otherwise false
public RFuture<Boolean> containsValueAsync(Object value)
RMapAsync
true
if this map contains any map entry
with specified value
, otherwise false
containsValueAsync
in interface RMapAsync<K,V>
value
- - map valuetrue
if this map contains any map entry
with specified value
, otherwise false
public Map<K,V> getAll(Set<K> keys)
RMap
keys
.
If map doesn't contain value/values for specified key/keys and MapLoader
is defined
then value/values will be loaded in read-through mode.
The returned map is NOT backed by the original map.
public RFuture<Map<K,V>> getAllAsync(Set<K> keys)
RMapAsync
keys
.
If map doesn't contain value/values for specified key/keys and MapLoader
is defined
then value/values will be loaded in read-through mode.
The returned map is NOT backed by the original map.
getAllAsync
in interface RMapAsync<K,V>
keys
- - map keysprotected boolean hasNoLoader()
public V get(Object key)
RMap
key
or null
if value is absent.
If map doesn't contain value for specified key and MapLoader
is defined
then value will be loaded in read-through mode.
public V put(K key, V value)
RMap
value
mapped by specified key
.
Returns previous value if map entry with specified key
already existed.
If MapWriter
is defined then map entry is stored in write-through mode.
public V remove(Object key)
RMap
key
and returns value.
If MapWriter
is defined then key
is deleted in write-through mode.
public final void putAll(Map<? extends K,? extends V> map)
RMap
map
object in batch mode.
If MapWriter
is defined then map entries will be stored in write-through mode.
public void putAll(Map<? extends K,? extends V> map, int batchSize)
RMap
map
object in batch mode.
Batch inserted by chunks limited by batchSize
value
to avoid OOM and/or Redis response timeout error for map with big size.
If MapWriter
is defined then map entries are stored in write-through mode.
public RFuture<Void> putAllAsync(Map<? extends K,? extends V> map, int batchSize)
RMapAsync
map
object in batch mode.
Batch inserted by chunks limited by batchSize
value
to avoid OOM and/or Redis response timeout error for map with big size.
If MapWriter
is defined then map entries are stored in write-through mode.
putAllAsync
in interface RMapAsync<K,V>
map
- mappings to be stored in this mapbatchSize
- - size of map entries batchpublic final RFuture<Void> putAllAsync(Map<? extends K,? extends V> map)
RMapAsync
map
object in batch mode.
If MapWriter
is defined then map entries will be stored in write-through mode.
putAllAsync
in interface RMapAsync<K,V>
map
- mappings to be stored in this mapprotected final <M> RFuture<M> mapWriterFuture(RFuture<M> future, MapWriterTask task)
protected final <M> RFuture<M> mapWriterFuture(RFuture<M> future, MapWriterTask task, Function<M,Boolean> condition)
public Set<K> keySet()
RMap
10
.public Set<K> keySet(String pattern)
RMap
pattern
is not null then only keys match this pattern are loaded.
Supported glob-style patterns:
h?llo subscribes to hello, hallo and hxllo
h*llo subscribes to hllo and heeeello
h[ae]llo subscribes to hello and hallo, but not hillo
keySet
in interface RMap<K,V>
pattern
- - key patternRMap.readAllKeySet()
public Set<K> keySet(String pattern, int count)
RMap
pattern
is not null then only keys match this pattern are loaded.
Keys are loaded in batch. Batch size is defined by count
param.
Supported glob-style patterns:
h?llo subscribes to hello, hallo and hxllo
h*llo subscribes to hllo and heeeello
h[ae]llo subscribes to hello and hallo, but not hillo
keySet
in interface RMap<K,V>
pattern
- - key patterncount
- - size of keys batchRMap.readAllKeySet()
public Set<K> keySet(int count)
RMap
count
param.keySet
in interface RMap<K,V>
count
- - size of keys batchRMap.readAllKeySet()
public Collection<V> values()
RMap
10
.public Collection<V> values(String keyPattern, int count)
RMap
count
param.
If keyPattern
is not null then only values mapped by matched keys of this pattern are loaded.
Supported glob-style patterns:
h?llo subscribes to hello, hallo and hxllo
h*llo subscribes to hllo and heeeello
h[ae]llo subscribes to hello and hallo, but not hillo
values
in interface RMap<K,V>
keyPattern
- - key patterncount
- - size of values batchRMap.readAllValues()
public Collection<V> values(String keyPattern)
RMap
10
.
If keyPattern
is not null then only values mapped by matched keys of this pattern are loaded.
Supported glob-style patterns:
h?llo subscribes to hello, hallo and hxllo
h*llo subscribes to hllo and heeeello
h[ae]llo subscribes to hello and hallo, but not hillo
values
in interface RMap<K,V>
keyPattern
- - key patternRMap.readAllValues()
public Collection<V> values(int count)
RMap
count
param.values
in interface RMap<K,V>
count
- - size of values batchRMap.readAllValues()
public Set<Map.Entry<K,V>> entrySet()
RMap
10
.public Set<Map.Entry<K,V>> entrySet(String keyPattern)
RMap
10
.
If keyPattern
is not null then only entries mapped by matched keys of this pattern are loaded.
Supported glob-style patterns:
h?llo subscribes to hello, hallo and hxllo
h*llo subscribes to hllo and heeeello
h[ae]llo subscribes to hello and hallo, but not hillo
entrySet
in interface RMap<K,V>
keyPattern
- - key patternRMap.readAllEntrySet()
public Set<Map.Entry<K,V>> entrySet(String keyPattern, int count)
RMap
count
param.
If keyPattern
is not null then only entries mapped by matched keys of this pattern are loaded.
Supported glob-style patterns:
h?llo subscribes to hello, hallo and hxllo
h*llo subscribes to hllo and heeeello
h[ae]llo subscribes to hello and hallo, but not hillo
entrySet
in interface RMap<K,V>
keyPattern
- - key patterncount
- - size of entries batchRMap.readAllEntrySet()
public Set<Map.Entry<K,V>> entrySet(int count)
RMap
count
param.entrySet
in interface RMap<K,V>
count
- - size of entries batchRMap.readAllEntrySet()
public Set<K> readAllKeySet()
RMap
readAllKeySet
in interface RMap<K,V>
public RFuture<Set<K>> readAllKeySetAsync()
RMapAsync
readAllKeySetAsync
in interface RMapAsync<K,V>
public Collection<V> readAllValues()
RMap
readAllValues
in interface RMap<K,V>
public RFuture<Collection<V>> readAllValuesAsync()
RMapAsync
readAllValuesAsync
in interface RMapAsync<K,V>
public Set<Map.Entry<K,V>> readAllEntrySet()
RMap
readAllEntrySet
in interface RMap<K,V>
public RFuture<Set<Map.Entry<K,V>>> readAllEntrySetAsync()
RMapAsync
readAllEntrySetAsync
in interface RMapAsync<K,V>
public Map<K,V> readAllMap()
RMap
readAllMap
in interface RMap<K,V>
public RFuture<Map<K,V>> readAllMapAsync()
RMapAsync
readAllMapAsync
in interface RMapAsync<K,V>
public V putIfAbsent(K key, V value)
RMap
value
mapped by specified key
only if there is no value with specifiedkey
stored before.
If MapWriter
is defined then new map entry is stored in write-through mode.
putIfAbsent
in interface ConcurrentMap<K,V>
putIfAbsent
in interface Map<K,V>
putIfAbsent
in interface RMap<K,V>
key
- - map keyvalue
- - map valuenull
if key is a new one in the hash and value was set.
Previous value if key already exists in the hash and change hasn't been made.public RFuture<V> putIfAbsentAsync(K key, V value)
RMapAsync
value
mapped by specified key
only if there is no value with specifiedkey
stored before.
If MapWriter
is defined then new map entry is stored in write-through mode.
putIfAbsentAsync
in interface RMapAsync<K,V>
key
- - map keyvalue
- - map valuenull
if key is a new one in the hash and value was set.
Previous value if key already exists in the hash and change hasn't been made.protected boolean hasNoWriter()
public boolean fastPutIfAbsent(K key, V value)
RMap
value
mapped by specified key
only if there is no value with specifiedkey
stored before.
Returns true
if key is a new one in the hash and value was set or
false
if key already exists in the hash and change hasn't been made.
Works faster than
but not returning
the previous value associated with RMap.putIfAbsent(Object, Object)
key
If MapWriter
is defined then new map entry is stored in write-through mode.
fastPutIfAbsent
in interface RMap<K,V>
key
- - map keyvalue
- - map valuetrue
if key is a new one in the hash and value was set.
false
if key already exists in the hash and change hasn't been made.public RFuture<Boolean> fastPutIfAbsentAsync(K key, V value)
RMapAsync
value
mapped by specified key
only if there is no value with specifiedkey
stored before.
Returns true
if key is a new one in the hash and value was set or
false
if key already exists in the hash and change hasn't been made.
Works faster than
but not returning
the previous value associated with RMapAsync.putIfAbsentAsync(Object, Object)
key
If MapWriter
is defined then new map entry is stored in write-through mode.
fastPutIfAbsentAsync
in interface RMapAsync<K,V>
key
- - map keyvalue
- - map valuetrue
if key is a new one in the hash and value was set.
false
if key already exists in the hash and change hasn't been made.protected RFuture<Boolean> fastPutIfAbsentOperationAsync(K key, V value)
public boolean remove(Object key, Object value)
RMap
key
and value
.
If MapWriter
is defined then key
is deleted in write-through mode.
public RFuture<Boolean> removeAsync(Object key, Object value)
RMapAsync
key
and value
.
If MapWriter
is defined then key
is deleted in write-through mode.
removeAsync
in interface RMapAsync<K,V>
key
- - map keyvalue
- - map valuetrue
if map entry has been removed otherwise false
.protected void checkValue(Object value)
public boolean replace(K key, V oldValue, V newValue)
RMap
oldValue
with a newValue
mapped by specified key
.
Returns false
if previous value doesn't exist or equal to oldValue
.
If MapWriter
is defined then newValue
is written in write-through mode.
public RFuture<Boolean> replaceAsync(K key, V oldValue, V newValue)
RMapAsync
oldValue
with a newValue
mapped by specified key
.
Returns false
if previous value doesn't exist or equal to oldValue
.
If MapWriter
is defined then newValue
is written in write-through mode.
replaceAsync
in interface RMapAsync<K,V>
key
- - map keyoldValue
- - map old valuenewValue
- - map new valuetrue
if value has been replaced otherwise false
.protected RFuture<Boolean> replaceOperationAsync(K key, V oldValue, V newValue)
public V replace(K key, V value)
RMap
value
mapped by specified key
.
Returns null
if there is no map entry stored before and doesn't store new map entry.
If MapWriter
is defined then new value
is written in write-through mode.
replace
in interface ConcurrentMap<K,V>
replace
in interface Map<K,V>
replace
in interface RMap<K,V>
key
- - map keyvalue
- - map valuenull
if there is no map entry stored before and doesn't store new map entrypublic RFuture<V> replaceAsync(K key, V value)
RMapAsync
value
mapped by specified key
.
Returns null
if there is no map entry stored before and doesn't store new map entry.
If MapWriter
is defined then new value
is written in write-through mode.
replaceAsync
in interface RMapAsync<K,V>
key
- - map keyvalue
- - map valuenull
if there is no map entry stored before and doesn't store new map entrypublic boolean fastReplace(K key, V value)
RMap
value
mapped by specified key
.
Works faster than
but not returning
the previous value.
RMap.replace(Object, Object)
Returns true
if key exists and value was updated or
false
if key doesn't exists and value wasn't updated.
If MapWriter
is defined then new map entry is stored in write-through mode.
fastReplace
in interface RMap<K,V>
key
- - map keyvalue
- - map valuetrue
if key exists and value was updated.
false
if key doesn't exists and value wasn't updated.public RFuture<Boolean> fastReplaceAsync(K key, V value)
RMapAsync
value
mapped by specified key
.
Works faster than
but not returning
the previous value.
RMapAsync.replaceAsync(Object, Object)
Returns true
if key exists and value was updated or
false
if key doesn't exists and value wasn't updated.
If MapWriter
is defined then new map entry is stored in write-through mode.
fastReplaceAsync
in interface RMapAsync<K,V>
key
- - map keyvalue
- - map valuetrue
if key exists and value was updated.
false
if key doesn't exists and value wasn't updated.public RFuture<V> getAsync(K key)
RMapAsync
key
or null
if value is absent.
If map doesn't contain value for specified key and MapLoader
is defined
then value will be loaded in read-through mode.
public void loadAll(boolean replaceExistingValues, int parallelism)
RMap
MapLoader
.public RFuture<Void> loadAllAsync(boolean replaceExistingValues, int parallelism)
RMapAsync
MapLoader
.loadAllAsync
in interface RMapAsync<K,V>
replaceExistingValues
- - true
if existed values should be replaced, false
otherwise.parallelism
- - parallelism level, used to increase speed of process executionpublic void loadAll(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)
RMap
MapLoader
whose keys are listed in defined keys
parameter.public RFuture<Void> loadAllAsync(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)
RMapAsync
MapLoader
whose keys are listed in defined keys
parameter.loadAllAsync
in interface RMapAsync<K,V>
keys
- - map keysreplaceExistingValues
- - true
if existed values should be replaced, false
otherwise.parallelism
- - parallelism level, used to increase speed of process executionpublic RFuture<V> putAsync(K key, V value)
RMapAsync
value
mapped by specified key
.
Returns previous value if map entry with specified key
already existed.
If MapWriter
is defined then map entry is stored in write-through mode.
public RFuture<V> removeAsync(K key)
RMapAsync
key
and returns value.
If MapWriter
is defined then key
is deleted in write-through mode.
removeAsync
in interface RMapAsync<K,V>
key
- - map keynull
if map entry doesn't existpublic RFuture<Boolean> fastPutAsync(K key, V value)
RMapAsync
value
mapped by specified key
.
Works faster than
but not returning
previous value.
RMapAsync.putAsync(Object, Object)
Returns true
if key is a new key in the hash and value was set or
false
if key already exists in the hash and the value was updated.
If MapWriter
is defined then map entry is stored in write-through mode.
fastPutAsync
in interface RMapAsync<K,V>
key
- - map keyvalue
- - map valuetrue
if key is a new key in the hash and value was set.
false
if key already exists in the hash and the value was updated.public boolean fastPut(K key, V value)
RMap
value
mapped by specified key
.
Works faster than
but not returning
previous value.
RMap.put(Object, Object)
Returns true
if key is a new key in the hash and value was set or
false
if key already exists in the hash and the value was updated.
If MapWriter
is defined then map entry is stored in write-through mode.
public RFuture<Long> fastRemoveAsync(K... keys)
RMapAsync
keys
.
Works faster than
but not returning
the value.
RMapAsync.removeAsync(Object)
If MapWriter
is defined then keys
are deleted in write-through mode.
fastRemoveAsync
in interface RMapAsync<K,V>
keys
- - map keysprotected RFuture<List<Long>> fastRemoveOperationBatchAsync(K... keys)
public long fastRemove(K... keys)
RMap
keys
.
Works faster than
but not returning
the value.
RMap.remove(Object)
If MapWriter
is defined then keys
are deleted in write-through mode.
fastRemove
in interface RMap<K,V>
keys
- - map keyspublic MapScanResult<Object,Object> scanIterator(String name, RedisClient client, long startPos, String pattern, int count)
public RFuture<MapScanResult<Object,Object>> scanIteratorAsync(String name, RedisClient client, long startPos, String pattern, int count)
public V addAndGet(K key, Number value)
RMap
delta
to the current value
by mapped key
.
Works only for numeric values!public RFuture<V> addAndGetAsync(K key, Number value)
RMapAsync
delta
to the current value
by mapped key
.
Works only for numeric values!addAndGetAsync
in interface RMapAsync<K,V>
key
- - map keyvalue
- the value to addpublic boolean equals(Object o)
public int hashCode()
public boolean expire(long timeToLive, TimeUnit timeUnit)
RExpirable
expire
in interface RExpirable
timeToLive
- - timeout before object will be deletedtimeUnit
- - timeout time unittrue
if the timeout was set and false
if notpublic RFuture<Boolean> expireAsync(long timeToLive, TimeUnit timeUnit)
RExpirableAsync
expireAsync
in interface RExpirableAsync
timeToLive
- - timeout before object will be deletedtimeUnit
- - timeout time unittrue
if the timeout was set and false
if notpublic boolean expireAt(long timestamp)
RExpirable
expireAt
in interface RExpirable
timestamp
- - expire date in milliseconds (Unix timestamp)true
if the timeout was set and false
if notpublic RFuture<Boolean> expireAtAsync(long timestamp)
RExpirableAsync
expireAtAsync
in interface RExpirableAsync
timestamp
- - expire date in milliseconds (Unix timestamp)true
if the timeout was set and false
if notpublic boolean expireAt(Date timestamp)
RExpirable
expireAt
in interface RExpirable
timestamp
- - expire datetrue
if the timeout was set and false
if notpublic RFuture<Boolean> expireAtAsync(Date timestamp)
RExpirableAsync
expireAtAsync
in interface RExpirableAsync
timestamp
- - expire datetrue
if the timeout was set and false
if notpublic boolean clearExpire()
RExpirable
clearExpire
in interface RExpirable
true
if timeout was removed
false
if object does not exist or does not have an associated timeoutpublic RFuture<Boolean> clearExpireAsync()
RExpirableAsync
clearExpireAsync
in interface RExpirableAsync
true
if the timeout was cleared and false
if notpublic long remainTimeToLive()
RExpirable
remainTimeToLive
in interface RExpirable
public RFuture<Long> remainTimeToLiveAsync()
RExpirableAsync
remainTimeToLiveAsync
in interface RExpirableAsync
protected RFuture<Boolean> expireAsync(long timeToLive, TimeUnit timeUnit, String... keys)
Copyright © 2014–2020 Redisson. All rights reserved.