RedissonMultimap (Redisson/All-in-One 3.7.3 API)

java.lang.Object
- org.redisson.RedissonObject
- - org.redisson.RedissonMultimap<K,V>

Type Parameters:

K - key

V - value

All Implemented Interfaces:

RExpirable, RExpirableAsync, RMultimap<K,V>, RMultimapAsync<K,V>, RObject, RObjectAsync

Direct Known Subclasses:

RedissonListMultimap, RedissonSetMultimap
```
public abstract class RedissonMultimap<K,V>
extends RedissonObject
implements RMultimap<K,V>
```
Author:

Nikita Koksharov

Field Summary
- Fields inherited from class org.redisson.RedissonObject
  codec, commandExecutor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Removes all key-value pairs from the multimap, leaving it empty.
`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`	`containsEntry(Object key, Object value)` Returns `true` if this multimap contains at least one key-value pair with the key `key` and the value `value`.
`boolean`	`containsKey(Object key)` Returns `true` if this multimap contains at least one key-value pair with the key `key`.
`boolean`	`containsValue(Object value)` Returns `true` if this multimap contains at least one key-value pair with the value `value`.
`RFuture<Boolean>`	`deleteAsync()` Delete object in async mode
`Collection<Map.Entry<K,V>>`	`entries()` Returns a view collection of all key-value pairs contained in this multimap, as `Map.Entry` instances.
`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.
`long`	`fastRemove(K... keys)` Removes `keys` from map by one operation Works faster than `RMultimap.remove` but not returning the value associated with `key`
`RFuture<Long>`	`fastRemoveAsync(K... keys)` Removes `keys` from map by one operation Works faster than `RMultimap.remove` but not returning the value associated with `key`
`protected <T> RFuture<T>`	`fastRemoveAsync(List<Object> mapKeys, List<Object> listKeys, RedisCommand<T> evalCommandType)`
`Collection<V>`	`getAll(K key)` Returns all elements at once.
`RLock`	`getLock(K key)` Returns `RLock` instance associated with key
`RReadWriteLock`	`getReadWriteLock(K key)` Returns `RReadWriteLock` instance associated with key
`protected String`	`hash(io.netty.buffer.ByteBuf objectState)`
`protected String`	`hashAndRelease(io.netty.buffer.ByteBuf objectState)`
`boolean`	`isEmpty()` Check is map empty
`Set<K>`	`keySet()` Returns a view collection of all distinct keys contained in this multimap.
`int`	`keySize()` Returns the count of distinct keys in this multimap.
`RFuture<Integer>`	`keySizeAsync()` Returns the number of key-value pairs in this multimap.
`boolean`	`put(K key, V value)` Stores a key-value pair in this multimap.
`boolean`	`putAll(K key, Iterable<? extends V> values)` Stores a key-value pair in this multimap for each of `values`, all using the same key, `key`.
`Set<K>`	`readAllKeySet()` Read all keys at once
`RFuture<Set<K>>`	`readAllKeySetAsync()` Read all keys 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
`boolean`	`remove(Object key, Object value)` Removes a single key-value pair with the key `key` and the value `value` from this multimap, if such exists.
`Collection<V>`	`removeAll(Object key)` Removes all values associated with the key `key`.
`Collection<V>`	`replaceValues(K key, Iterable<? extends V> values)` Stores a collection of values with the same key, replacing any existing values for that key.
`int`	`size()` Returns the number of key-value pairs in this multimap.
`Collection<V>`	`values()` Returns a view collection containing the value from each key-value pair contained in this multimap, without collapsing duplicates (so `values().size() == size()`).

Methods inherited from class org.redisson.RedissonObject
await, copy, copyAsync, delete, encode, encode, encode, encodeMapKey, encodeMapKeys, encodeMapValue, encodeMapValues, get, getCodec, getName, getName, isExists, isExistsAsync, migrate, migrateAsync, move, moveAsync, prefixName, rename, renameAsync, renamenx, renamenxAsync, suffixName, toSeconds, touch, touchAsync, unlink, unlinkAsync

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

Methods inherited from interface org.redisson.api.RMultimap
get

Methods inherited from interface org.redisson.api.RExpirable
clearExpire, expire, expireAt, expireAt, remainTimeToLive

Methods inherited from interface org.redisson.api.RObject
copy, delete, getCodec, getName, isExists, migrate, move, rename, renamenx, touch, unlink

Methods inherited from interface org.redisson.api.RMultimapAsync
containsEntryAsync, containsKeyAsync, containsValueAsync, getAllAsync, putAllAsync, putAsync, removeAllAsync, removeAsync, replaceValuesAsync, sizeAsync

Methods inherited from interface org.redisson.api.RExpirableAsync
expireAtAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.api.RObjectAsync
copyAsync, isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync, touchAsync, unlinkAsync

- Method Detail
  - getLock
```
public RLock getLock(K key)
```
    Description copied from interface: RMultimap
    
    Returns RLock instance associated with key
    
    Specified by:
    
    getLock in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    Returns:
    
    lock
  - getReadWriteLock
```
public RReadWriteLock getReadWriteLock(K key)
```
    Description copied from interface: RMultimap
    
    Returns RReadWriteLock instance associated with key
    
    Specified by:
    
    getReadWriteLock in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    Returns:
    
    readWriteLock
  - hash
```
protected String hash(io.netty.buffer.ByteBuf objectState)
```
  - hashAndRelease
```
protected String hashAndRelease(io.netty.buffer.ByteBuf objectState)
```
  - size
```
public int size()
```
    Description copied from interface: RMultimap
    
    Returns the number of key-value pairs in this multimap.
    
    Specified by:
    
    size in interface RMultimap<K,V>
    
    Returns:
    
    size of multimap
  - keySize
```
public int keySize()
```
    Description copied from interface: RMultimap
    
    Returns the count of distinct keys in this multimap.
    
    Specified by:
    
    keySize in interface RMultimap<K,V>
    
    Returns:
    
    keys amount
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: RMultimap
    
    Check is map empty
    
    Specified by:
    
    isEmpty in interface RMultimap<K,V>
    
    Returns:
    
    true if empty
  - containsKey
```
public boolean containsKey(Object key)
```
    Description copied from interface: RMultimap
    
    Returns true if this multimap contains at least one key-value pair with the key key.
    
    Specified by:
    
    containsKey in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    Returns:
    
    true if contains a key
  - containsValue
```
public boolean containsValue(Object value)
```
    Description copied from interface: RMultimap
    
    Returns true if this multimap contains at least one key-value pair with the value value.
    
    Specified by:
    
    containsValue in interface RMultimap<K,V>
    
    Parameters:
    
    value - - map value
    
    Returns:
    
    true if contains a value
  - containsEntry
```
public boolean containsEntry(Object key,
                             Object value)
```
    Description copied from interface: RMultimap
    
    Returns true if this multimap contains at least one key-value pair with the key key and the value value.
    
    Specified by:
    
    containsEntry in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    Returns:
    
    true if contains an entry
  - put
```
public boolean put(K key,
                   V value)
```
    Description copied from interface: RMultimap
    
    Stores a key-value pair in this multimap.
    Some multimap implementations allow duplicate key-value pairs, in which case put always adds a new key-value pair and increases the multimap size by 1. Other implementations prohibit duplicates, and storing a key-value pair that's already in the multimap has no effect.
    
    Specified by:
    
    put in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    Returns:
    
    true if the method increased the size of the multimap, or false if the multimap already contained the key-value pair and doesn't allow duplicates
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Description copied from interface: RMultimap
    
    Removes a single key-value pair with the key key and the value value from this multimap, if such exists. If multiple key-value pairs in the multimap fit this description, which one is removed is unspecified.
    
    Specified by:
    
    remove in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    Returns:
    
    true if the multimap changed
  - putAll
```
public boolean putAll(K key,
                      Iterable<? extends V> values)
```
    Description copied from interface: RMultimap
    Stores a key-value pair in this multimap for each of values, all using the same key, key. Equivalent to (but expected to be more efficient than):
```
   

   for (V value : values) {
     put(key, value);
   }
```
    In particular, this is a no-op if values is empty.
    Specified by:
    
    putAll in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    values - - map values
    
    Returns:
    
    true if the multimap changed
  - clear
```
public void clear()
```
    Description copied from interface: RMultimap
    
    Removes all key-value pairs from the multimap, leaving it empty.
    
    Specified by:
    
    clear in interface RMultimap<K,V>
  - keySet
```
public Set<K> keySet()
```
    Description copied from interface: RMultimap
    
    Returns a view collection of all distinct keys contained in this multimap. Note that the key set contains a key if and only if this multimap maps that key to at least one value.
    Changes to the returned set will update the underlying multimap, and vice versa. However, adding to the returned set is not possible.
    
    Specified by:
    
    keySet in interface RMultimap<K,V>
    
    Returns:
    
    set of keys
  - values
```
public Collection<V> values()
```
    Description copied from interface: RMultimap
    
    Returns a view collection containing the value from each key-value pair contained in this multimap, without collapsing duplicates (so values().size() == size()).
    Changes to the returned collection will update the underlying multimap, and vice versa. However, adding to the returned collection is not possible.
    
    Specified by:
    
    values in interface RMultimap<K,V>
    
    Returns:
    
    collection of values
  - getAll
```
public Collection<V> getAll(K key)
```
    Description copied from interface: RMultimap
    
    Returns all elements at once. Result collection is NOT backed by map, so changes are not reflected in map.
    
    Specified by:
    
    getAll in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    Returns:
    
    collection of values
  - removeAll
```
public Collection<V> removeAll(Object key)
```
    Description copied from interface: RMultimap
    
    Removes all values associated with the key key.
    Once this method returns, key will not be mapped to any values
    Use RMultimap.fastRemove(K...) if values are not needed.
    
    Specified by:
    
    removeAll in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    Returns:
    
    the values that were removed (possibly empty). The returned collection may be modifiable, but updating it will have no effect on the multimap.
  - replaceValues
```
public Collection<V> replaceValues(K key,
                                   Iterable<? extends V> values)
```
    Description copied from interface: RMultimap
    
    Stores a collection of values with the same key, replacing any existing values for that key.
    If values is empty, this is equivalent to removeAll(key).
    
    Specified by:
    
    replaceValues in interface RMultimap<K,V>
    
    Parameters:
    
    key - - map key
    
    values - - map values
    
    Returns:
    
    the collection of replaced values, or an empty collection if no values were previously associated with the key. The collection may be modifiable, but updating it will have no effect on the multimap.
  - entries
```
public Collection<Map.Entry<K,V>> entries()
```
    Description copied from interface: RMultimap
    
    Returns a view collection of all key-value pairs contained in this multimap, as Map.Entry instances.
    Changes to the returned collection or the entries it contains will update the underlying multimap, and vice versa. However, adding to the returned collection is not possible.
    
    Specified by:
    
    entries in interface RMultimap<K,V>
    
    Returns:
    
    collection of entries
  - readAllKeySet
```
public Set<K> readAllKeySet()
```
    Description copied from interface: RMultimap
    
    Read all keys at once
    
    Specified by:
    
    readAllKeySet in interface RMultimap<K,V>
    
    Returns:
    
    keys
  - readAllKeySetAsync
```
public RFuture<Set<K>> readAllKeySetAsync()
```
    Description copied from interface: RMultimapAsync
    
    Read all keys at once
    
    Specified by:
    
    readAllKeySetAsync in interface RMultimapAsync<K,V>
    
    Returns:
    
    keys
  - fastRemove
```
public long fastRemove(K... keys)
```
    Description copied from interface: RMultimap
    
    Removes keys from map by one operation Works faster than RMultimap.remove but not returning the value associated with key
    
    Specified by:
    
    fastRemove in interface RMultimap<K,V>
    
    Parameters:
    
    keys - - map keys
    
    Returns:
    
    the number of keys that were removed from the hash, not including specified but non existing keys
  - fastRemoveAsync
```
public RFuture<Long> fastRemoveAsync(K... keys)
```
    Description copied from interface: RMultimapAsync
    
    Removes keys from map by one operation Works faster than RMultimap.remove but not returning the value associated with key
    
    Specified by:
    
    fastRemoveAsync in interface RMultimapAsync<K,V>
    
    Parameters:
    
    keys - - map keys
    
    Returns:
    
    the number of keys that were removed from the hash, not including specified but non existing keys
  - fastRemoveAsync
```
protected <T> RFuture<T> fastRemoveAsync(List<Object> mapKeys,
                                         List<Object> listKeys,
                                         RedisCommand<T> evalCommandType)
```
  - deleteAsync
```
public RFuture<Boolean> deleteAsync()
```
    Description copied from interface: RObjectAsync
    
    Delete object in async mode
    
    Specified by:
    
    deleteAsync in interface RObjectAsync
    
    Overrides:
    
    deleteAsync in class RedissonObject
    
    Returns:
    
    true if object was deleted false if not
  - expireAsync
```
public RFuture<Boolean> expireAsync(long timeToLive,
                                    TimeUnit timeUnit)
```
    Description copied from interface: RExpirableAsync
    
    Set a timeout for object in async mode. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expireAsync in interface RExpirableAsync
    
    Parameters:
    
    timeToLive - - timeout before object will be deleted
    
    timeUnit - - timeout time unit
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAtAsync
```
public RFuture<Boolean> expireAtAsync(long timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Set an expire date for object in async mode. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    Parameters:
    
    timestamp - - expire date in seconds (Unix timestamp)
    
    Returns:
    
    true if the timeout was set and false if not
  - clearExpireAsync
```
public RFuture<Boolean> clearExpireAsync()
```
    Description copied from interface: RExpirableAsync
    
    Clear an expire timeout or expire date for object in async mode. Object will not be deleted.
    
    Specified by:
    
    clearExpireAsync in interface RExpirableAsync
    
    Returns:
    
    true if the timeout was cleared and false if not
  - keySizeAsync
```
public RFuture<Integer> keySizeAsync()
```
    Description copied from interface: RMultimapAsync
    
    Returns the number of key-value pairs in this multimap.
    
    Specified by:
    
    keySizeAsync in interface RMultimapAsync<K,V>
    
    Returns:
    
    keys amount
  - expire
```
public boolean expire(long timeToLive,
                      TimeUnit timeUnit)
```
    Description copied from interface: RExpirable
    
    Set a timeout for object. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expire in interface RExpirable
    
    Parameters:
    
    timeToLive - - timeout before object will be deleted
    
    timeUnit - - timeout time unit
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAt
```
public boolean expireAt(long timestamp)
```
    Description copied from interface: RExpirable
    
    Set an expire date for object. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAt in interface RExpirable
    
    Parameters:
    
    timestamp - - expire date in milliseconds (Unix timestamp)
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAt
```
public boolean expireAt(Date timestamp)
```
    Description copied from interface: RExpirable
    
    Set an expire date for object. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAt in interface RExpirable
    
    Parameters:
    
    timestamp - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAtAsync
```
public RFuture<Boolean> expireAtAsync(Date timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Set an expire date for object in async mode. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    Parameters:
    
    timestamp - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - clearExpire
```
public boolean clearExpire()
```
    Description copied from interface: RExpirable
    
    Clear an expire timeout or expire date for object.
    
    Specified by:
    
    clearExpire in interface RExpirable
    
    Returns:
    
    true if timeout was removed false if object does not exist or does not have an associated timeout
  - remainTimeToLive
```
public long remainTimeToLive()
```
    Description copied from interface: RExpirable
    
    Remaining time to live of Redisson object that has a timeout
    
    Specified by:
    
    remainTimeToLive in interface RExpirable
    
    Returns:
    
    time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.
  - remainTimeToLiveAsync
```
public RFuture<Long> remainTimeToLiveAsync()
```
    Description copied from interface: RExpirableAsync
    
    Remaining time to live of Redisson object that has a timeout
    
    Specified by:
    
    remainTimeToLiveAsync in interface RExpirableAsync
    
    Returns:
    
    time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.

Class RedissonMultimap<K,V>

Field Summary

Fields inherited from class org.redisson.RedissonObject

Method Summary

Methods inherited from class org.redisson.RedissonObject

Methods inherited from class java.lang.Object

Methods inherited from interface org.redisson.api.RMultimap

Methods inherited from interface org.redisson.api.RExpirable

Methods inherited from interface org.redisson.api.RObject

Methods inherited from interface org.redisson.api.RMultimapAsync

Methods inherited from interface org.redisson.api.RExpirableAsync

Methods inherited from interface org.redisson.api.RObjectAsync

Method Detail

getLock

getReadWriteLock

hash

hashAndRelease

size

keySize

isEmpty

containsKey

containsValue

containsEntry

put

remove

putAll

clear

keySet

values

getAll

removeAll

replaceValues

entries

readAllKeySet

readAllKeySetAsync

fastRemove

fastRemoveAsync

fastRemoveAsync

deleteAsync

expireAsync

expireAtAsync

clearExpireAsync

keySizeAsync

expire

expireAt

expireAt

expireAtAsync

clearExpire

remainTimeToLive

remainTimeToLiveAsync