K - keyV - valuepublic class RedissonMap<K,V> extends RedissonObject implements RMap<K,V>
ConcurrentMap
and Mapcodec, commandExecutor| 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)
Atomically adds the given
delta to the current value
by mapped key. |
RFuture<V> |
addAndGetAsync(K key,
Number value)
Atomically 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.
|
boolean |
containsKey(Object key) |
RFuture<Boolean> |
containsKeyAsync(Object key) |
boolean |
containsValue(Object value) |
RFuture<Boolean> |
containsValueAsync(Object value) |
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.
|
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.
|
boolean |
fastPut(K key,
V value)
Associates the specified
value with the specified key. |
RFuture<Boolean> |
fastPutAsync(K key,
V value)
Associates the specified
value with the specified key
in async manner. |
boolean |
fastPutIfAbsent(K key,
V value)
Associates the specified
value with the specified key
only if there is no any association with specifiedkey. |
RFuture<Boolean> |
fastPutIfAbsentAsync(K key,
V value)
Associates the specified
value with the specified key
only if there is no any association with specifiedkey. |
protected RFuture<Boolean> |
fastPutIfAbsentOperationAsync(K key,
V value) |
protected RFuture<Boolean> |
fastPutOperationAsync(K key,
V value) |
long |
fastRemove(K... keys)
Removes
keys from map by one operation
Works faster than key
If MapWriter is defined then keysare deleted in write-through mode. |
RFuture<Long> |
fastRemoveAsync(K... keys)
Removes
keys from map by one operation in async manner. |
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 associated with the key. |
RFuture<Boolean> |
fastReplaceAsync(K key,
V value)
Replaces previous value with a new
value associated with the key. |
protected RFuture<Boolean> |
fastReplaceOperationAsync(K key,
V value) |
V |
get(Object key)
Returns the value to which the specified key is mapped,
or
null if this map contains no mapping for the key. |
Map<K,V> |
getAll(Set<K> keys)
Gets a map slice contained the mappings with defined
keys
by one operation. |
RFuture<Map<K,V>> |
getAllAsync(Set<K> keys)
Gets a map slice contained the mappings with defined
keys
by one operation. |
RFuture<Map<K,V>> |
getAllOperationAsync(Set<K> keys) |
RFuture<V> |
getAsync(K key)
Returns the value to which the specified key is mapped,
or
null if this map contains no mapping for the key. |
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)
Associates the specified
value with the specified key
in async manner. |
void |
putAll(Map<? extends K,? extends V> map)
Associates the specified
value with the specified key
in batch. |
void |
putAll(Map<? extends K,? extends V> map,
int batchSize)
Associates the specified
value with the specified key
in batch. |
RFuture<Void> |
putAllAsync(Map<? extends K,? extends V> map)
Associates the specified
value with the specified key
in batch. |
RFuture<Void> |
putAllAsync(Map<? extends K,? extends V> map,
int batchSize)
Associates the specified
value with the specified key
in batch. |
protected RFuture<Void> |
putAllOperationAsync(Map<? extends K,? extends V> map) |
RFuture<V> |
putAsync(K key,
V value)
Associates the specified
value with the specified key
in async manner. |
V |
putIfAbsent(K key,
V value)
Associates the specified
value with the specified key
only if there is no any association with specifiedkey. |
RFuture<V> |
putIfAbsentAsync(K key,
V value)
Associates the specified
value with the specified key
only if there is no any association with specifiedkey. |
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
key from map and returns associated value in async manner. |
boolean |
remove(Object key,
Object value)
Removes
key from map only if it associated with value. |
RFuture<V> |
removeAsync(K key)
Removes
key from map and returns associated value in async manner. |
RFuture<Boolean> |
removeAsync(Object key,
Object value)
Removes
key from map only if it associated with 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 associated with the key. |
boolean |
replace(K key,
V oldValue,
V newValue)
Replaces previous
oldValue with a newValue associated with the key. |
RFuture<V> |
replaceAsync(K key,
V value)
Replaces previous value with a new
value associated with the key. |
RFuture<Boolean> |
replaceAsync(K key,
V oldValue,
V newValue)
Replaces previous
oldValue with a newValue associated with the 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 key in bytes
|
RFuture<Integer> |
valueSizeAsync(K key)
Returns size of value mapped by key in bytes
|
addListener, addListenerAsync, await, copy, copyAsync, delete, deleteAsync, dump, dumpAsync, encode, encode, encode, encodeMapKey, encodeMapKeys, encodeMapValue, encodeMapValues, get, getCodec, getLockByMapKey, getLockByValue, getName, getName, isExists, isExistsAsync, migrate, migrateAsync, move, moveAsync, prefixName, removeListener, removeListenerAsync, rename, renameAsync, renamenx, renamenxAsync, restore, restore, restoreAndReplace, restoreAndReplace, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemory, sizeInMemoryAsync, sizeInMemoryAsync, suffixName, toSeconds, toStream, touch, touchAsync, unlink, unlinkAsyncclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitcompute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAllclearExpire, expire, expireAt, expireAt, remainTimeToLiveaddListener, copy, delete, dump, getCodec, getName, isExists, migrate, move, removeListener, rename, renamenx, restore, restore, restoreAndReplace, restoreAndReplace, sizeInMemory, touch, unlinkclearExpireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsyncaddListenerAsync, copyAsync, deleteAsync, dumpAsync, isExistsAsync, migrateAsync, moveAsync, removeListenerAsync, renameAsync, renamenxAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemoryAsync, touchAsync, unlinkAsyncpublic 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()
RMapRMapReduce object associated with this mappublic RPermitExpirableSemaphore getPermitExpirableSemaphore(K key)
RMapRPermitExpirableSemaphore instance associated with keygetPermitExpirableSemaphore in interface RMap<K,V>key - - map keypublic RSemaphore getSemaphore(K key)
RMapRSemaphore instance associated with keygetSemaphore in interface RMap<K,V>key - - map keypublic RCountDownLatch getCountDownLatch(K key)
RMapRCountDownLatch instance associated with keygetCountDownLatch in interface RMap<K,V>key - - map keypublic RLock getFairLock(K key)
RMapRLock instance associated with keygetFairLock in interface RMap<K,V>key - - map keypublic RLock getLock(K key)
RMapRLock instance associated with keypublic RReadWriteLock getReadWriteLock(K key)
RMapRReadWriteLock instance associated with keygetReadWriteLock in interface RMap<K,V>key - - map keypublic RFuture<Integer> sizeAsync()
RMapAsyncpublic int valueSize(K key)
RMappublic RFuture<Integer> valueSizeAsync(K key)
RMapAsyncvalueSizeAsync in interface RMapAsync<K,V>key - - map keyprotected void checkKey(Object key)
public boolean containsKey(Object key)
containsKey in interface Map<K,V>public RFuture<Boolean> containsKeyAsync(Object key)
containsKeyAsync in interface RMapAsync<K,V>public boolean containsValue(Object value)
containsValue in interface Map<K,V>public RFuture<Boolean> containsValueAsync(Object value)
containsValueAsync in interface RMapAsync<K,V>public Map<K,V> getAll(Set<K> keys)
RMapkeys
by one operation.
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)
RMapAsynckeys
by one operation.
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)
RMapnull if this map contains no mapping for the key.
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)
RMapvalue with the specified key
in async manner.
If MapWriter is defined then new map entry is stored in write-through mode.
public V remove(Object key)
RMapkey from map and returns associated value in async manner.
If MapWriter is defined then keyis deleted in write-through mode.
public final void putAll(Map<? extends K,? extends V> map)
RMapvalue with the specified key
in batch.
If MapWriter is defined then new map entries will be stored in write-through mode.
public void putAll(Map<? extends K,? extends V> map, int batchSize)
RMapvalue with the specified key
in batch. Batch inserted by chunks limited by batchSize amount
to avoid OOM and/or Redis response timeout error for map with big size.
If MapWriter is defined then new map entries are stored in write-through mode.
public RFuture<Void> putAllAsync(Map<? extends K,? extends V> map, int batchSize)
RMapAsyncvalue with the specified key
in batch. Batch inserted by chunks limited by batchSize amount
to avoid OOM and/or Redis response timeout error for map with big size.
If MapWriter is defined then new map entries are stored in write-through mode.
putAllAsync in interface RMapAsync<K,V>map - mappings to be stored in this mapbatchSize - - map chunk sizepublic final RFuture<Void> putAllAsync(Map<? extends K,? extends V> map)
RMapAsyncvalue with the specified key
in batch.
If MapWriter is defined then new map entries are 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()
RMap10.public Set<K> keySet(String pattern)
RMappattern 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)
RMappattern 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)
RMapcount param.keySet in interface RMap<K,V>count - - size of keys batchRMap.readAllKeySet()public Collection<V> values()
RMap10.public Collection<V> values(String keyPattern, int count)
RMapcount 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)
RMap10.
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)
RMapcount param.values in interface RMap<K,V>count - - size of values batchRMap.readAllValues()public Set<Map.Entry<K,V>> entrySet()
RMap10.public Set<Map.Entry<K,V>> entrySet(String keyPattern)
RMap10.
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)
RMapcount 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)
RMapcount param.entrySet in interface RMap<K,V>count - - size of entries batchRMap.readAllEntrySet()public Set<K> readAllKeySet()
RMapreadAllKeySet in interface RMap<K,V>public RFuture<Set<K>> readAllKeySetAsync()
RMapAsyncreadAllKeySetAsync in interface RMapAsync<K,V>public Collection<V> readAllValues()
RMapreadAllValues in interface RMap<K,V>public RFuture<Collection<V>> readAllValuesAsync()
RMapAsyncreadAllValuesAsync in interface RMapAsync<K,V>public Set<Map.Entry<K,V>> readAllEntrySet()
RMapreadAllEntrySet in interface RMap<K,V>public RFuture<Set<Map.Entry<K,V>>> readAllEntrySetAsync()
RMapAsyncreadAllEntrySetAsync in interface RMapAsync<K,V>public Map<K,V> readAllMap()
RMapreadAllMap in interface RMap<K,V>public RFuture<Map<K,V>> readAllMapAsync()
RMapAsyncreadAllMapAsync in interface RMapAsync<K,V>public V putIfAbsent(K key, V value)
RMapvalue with the specified key
only if there is no any association with specifiedkey.
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)
RMapAsyncvalue with the specified key
only if there is no any association with specifiedkey.
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)
RMapvalue with the specified key
only if there is no any association with specifiedkey.
Works faster than 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)
RMapAsyncvalue with the specified key
only if there is no any association with specifiedkey.
Works faster than 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)
RMapkey from map only if it associated with value.
If MapWriter is defined then keyis deleted in write-through mode.
public RFuture<Boolean> removeAsync(Object key, Object value)
RMapAsynckey from map only if it associated with value.
If MapWriter is defined then keyis deleted in write-through mode.
removeAsync in interface RMapAsync<K,V>key - - map keyvalue - - map valuetrue if map entry has been replaced otherwise false.protected void checkValue(Object value)
public boolean replace(K key, V oldValue, V newValue)
RMapoldValue with a newValue associated with the key.
If previous value doesn't exist or equal to oldValue then method returns false.
If MapWriter is defined then newValueis written in write-through mode.
public RFuture<Boolean> replaceAsync(K key, V oldValue, V newValue)
RMapAsyncoldValue with a newValue associated with the key.
If previous value doesn't exist or equal to oldValue then method returns false.
If MapWriter is defined then newValueis 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)
RMapvalue associated with the key.
If there wasn't any association before then method returns null.
If MapWriter is defined then new valueis written in write-through mode.
public RFuture<V> replaceAsync(K key, V value)
RMapAsyncvalue associated with the key.
If there wasn't any association before then method returns null.
If MapWriter is defined then new valueis written in write-through mode.
replaceAsync in interface RMapAsync<K,V>key - - map keyvalue - - map valuenull if there wasn't any association and change hasn't been madepublic boolean fastReplace(K key, V value)
RMapvalue associated with the key.
Works faster than RMap.replace(Object, Object)key
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)
RMapAsyncvalue associated with the key.
Works faster than RMapAsync.replaceAsync(Object, Object)key
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)
RMapAsyncnull if this map contains no mapping for the key.
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)
RMapMapLoader.public RFuture<Void> loadAllAsync(boolean replaceExistingValues, int parallelism)
RMapAsyncMapLoader.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)
RMapMapLoader whose keys are listed in defined keys parameter.public RFuture<Void> loadAllAsync(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)
RMapAsyncMapLoader 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)
RMapAsyncvalue with the specified key
in async manner.
If MapWriter is defined then new map entry is stored in write-through mode.
public RFuture<V> removeAsync(K key)
RMapAsynckey from map and returns associated value in async manner.
If MapWriter is defined then keyis deleted in write-through mode.
removeAsync in interface RMapAsync<K,V>key - - map keynull if there wasn't any associationpublic RFuture<Boolean> fastPutAsync(K key, V value)
RMapAsyncvalue with the specified key
in async manner.
Works faster than RMapAsync.putAsync(Object, Object)key
If MapWriter is defined then new map entry is stored in write-through mode.
fastPutAsync 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 the value was updated.public boolean fastPut(K key, V value)
RMapvalue with the specified key.
Works faster than RMap.put(Object, Object)key
If MapWriter is defined then new map entry is stored in write-through mode.
public RFuture<Long> fastRemoveAsync(K... keys)
RMapAsynckeys from map by one operation in async manner.
Works faster than RMapAsync.removeAsync(Object, Object)key.
If MapWriter is defined then keysare 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)
RMapkeys from map by one operation
Works faster than RMap.remove(Object)key
If MapWriter is defined then keysare 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)
RMapdelta to the current value
by mapped key.
Works only for numeric values!public RFuture<V> addAndGetAsync(K key, Number value)
RMapAsyncdelta to the current value
by mapped key.
Works only for numeric values!addAndGetAsync in interface RMapAsync<K,V>key - - map keyvalue - - delta the value to addpublic boolean equals(Object o)
public int hashCode()
public boolean expire(long timeToLive,
TimeUnit timeUnit)
RExpirableexpire in interface RExpirabletimeToLive - - 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)
RExpirableAsyncexpireAsync in interface RExpirableAsynctimeToLive - - timeout before object will be deletedtimeUnit - - timeout time unittrue if the timeout was set and false if notpublic boolean expireAt(long timestamp)
RExpirableexpireAt in interface RExpirabletimestamp - - expire date in milliseconds (Unix timestamp)true if the timeout was set and false if notpublic RFuture<Boolean> expireAtAsync(long timestamp)
RExpirableAsyncexpireAtAsync in interface RExpirableAsynctimestamp - - expire date in milliseconds (Unix timestamp)true if the timeout was set and false if notpublic boolean expireAt(Date timestamp)
RExpirableexpireAt in interface RExpirabletimestamp - - expire datetrue if the timeout was set and false if notpublic RFuture<Boolean> expireAtAsync(Date timestamp)
RExpirableAsyncexpireAtAsync in interface RExpirableAsynctimestamp - - expire datetrue if the timeout was set and false if notpublic boolean clearExpire()
RExpirableclearExpire in interface RExpirabletrue if timeout was removed
false if object does not exist or does not have an associated timeoutpublic RFuture<Boolean> clearExpireAsync()
RExpirableAsyncclearExpireAsync in interface RExpirableAsynctrue if the timeout was cleared and false if notpublic long remainTimeToLive()
RExpirableremainTimeToLive in interface RExpirablepublic RFuture<Long> remainTimeToLiveAsync()
RExpirableAsyncremainTimeToLiveAsync in interface RExpirableAsyncCopyright © 2014–2019 The Redisson Project. All rights reserved.