RedissonMultimap (Redisson 2.2.27 API)

java.lang.Object
- 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 Object
implements RMultimap<K,V>
```
Author:

Nikita Koksharov

Method Summary

Methods
Modifier and Type	Method and Description
`protected boolean`	`await(io.netty.util.concurrent.Future<?> future, long timeout, TimeUnit timeoutUnit)`
`void`	`clear()` Removes all key-value pairs from the multimap, leaving it empty.
`boolean`	`clearExpire()` Clear an expire timeout or expire date for object.
`io.netty.util.concurrent.Future<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`.
`boolean`	`delete()` Deletes the object
`io.netty.util.concurrent.Future<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.
`io.netty.util.concurrent.Future<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.
`io.netty.util.concurrent.Future<Boolean>`	`expireAtAsync(Date timestamp)` Set an expire date for object in async mode.
`io.netty.util.concurrent.Future<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`
`io.netty.util.concurrent.Future<Long>`	`fastRemoveAsync(K... keys)` Removes `keys` from map by one operation Works faster than `removeAll` but not returning the value associated with `key`
`protected <V> V`	`get(io.netty.util.concurrent.Future<V> future)`
`Collection<V>`	`getAll(K key)` Returns all elements at once.
`String`	`getName()` Returns name of object
`protected String`	`hash(byte[] objectState)`
`boolean`	`isEmpty()` Check is map empty
`boolean`	`isExists()` Check object existence
`io.netty.util.concurrent.Future<Boolean>`	`isExistsAsync()` Check object existence in async mode.
`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.
`io.netty.util.concurrent.Future<Integer>`	`keySizeAsync()` Returns the number of key-value pairs in this multimap.
`void`	`migrate(String host, int port, int database)` Transfer an object from source Redis instance to destination Redis instance
`io.netty.util.concurrent.Future<Void>`	`migrateAsync(String host, int port, int database)` Transfer an object from source Redis instance to destination Redis instance in async mode
`boolean`	`move(int database)` Move object to another database
`io.netty.util.concurrent.Future<Boolean>`	`moveAsync(int database)` Move object to another database in async mode
`protected <V> io.netty.util.concurrent.Promise<V>`	`newPromise()`
`protected <V> io.netty.util.concurrent.Future<V>`	`newSucceededFuture(V result)`
`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`.
`long`	`remainTimeToLive()` Remaining time to live of Redisson object that has a timeout
`io.netty.util.concurrent.Future<Long>`	`remainTimeToLiveAsync()` Get remaining time to live of object in seconds.
`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`.
`void`	`rename(String newName)` Rename current object key to `newName`
`io.netty.util.concurrent.Future<Void>`	`renameAsync(String newName)` Rename current object key to `newName` in async mode
`boolean`	`renamenx(String newName)` Rename current object key to `newName` only if new key is not exists
`io.netty.util.concurrent.Future<Boolean>`	`renamenxAsync(String newName)` Rename current object key to `newName` in async mode only if new key is not exists
`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 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

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

Methods inherited from interface org.redisson.core.RObject
delete, getName, isExists, migrate, move, rename, renamenx

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

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

Methods inherited from interface org.redisson.core.RObjectAsync
isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync

- Method Detail
  - hash
```
protected String hash(byte[] 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:
  - 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>
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: RMultimap
    
    Check is map empty
    
    Specified by:
    
    isEmpty in interface RMultimap<K,V>
    
    Returns:
  - 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>
  - 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>
  - 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>
  - 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>
    
    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>
    
    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>
    
    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>
  - 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>
  - 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>
    
    Returns:
  - 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, so it will not appear in RMultimap.keySet(), #asMap(), or any other views.
    Use #fastRemove() if values are not needed.
    
    Specified by:
    
    removeAll in interface RMultimap<K,V>
    
    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>
    
    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>
  - 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>
    
    Returns:
    the number of keys that were removed from the hash, not including specified but non existing keys
  - fastRemoveAsync
```
public io.netty.util.concurrent.Future<Long> fastRemoveAsync(K... keys)
```
    Description copied from interface: RMultimapAsync
    
    Removes keys from map by one operation Works faster than removeAll but not returning the value associated with key
    
    Specified by:
    
    fastRemoveAsync in interface RMultimapAsync<K,V>
    
    Returns:
    the number of keys that were removed from the hash, not including specified but non existing keys
  - deleteAsync
```
public io.netty.util.concurrent.Future<Boolean> deleteAsync()
```
    Description copied from interface: RObjectAsync
    
    Delete object in async mode
    
    Specified by:
    
    deleteAsync in interface RObjectAsync
    
    Returns:
    true if object was deleted false if not
  - expireAsync
```
public io.netty.util.concurrent.Future<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 io.netty.util.concurrent.Future<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 io.netty.util.concurrent.Future<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 io.netty.util.concurrent.Future<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:
  - 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 io.netty.util.concurrent.Future<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 io.netty.util.concurrent.Future<Long> remainTimeToLiveAsync()
```
    Description copied from interface: RExpirableAsync
    
    Get remaining time to live of object in seconds.
    
    Specified by:
    
    remainTimeToLiveAsync in interface RExpirableAsync
    
    Returns:
    -1 if object does not exist or time in seconds
  - await
```
protected boolean await(io.netty.util.concurrent.Future<?> future,
            long timeout,
            TimeUnit timeoutUnit)
                 throws InterruptedException
```
    Throws:
    
    InterruptedException
  - get
```
protected <V> V get(io.netty.util.concurrent.Future<V> future)
```
  - newPromise
```
protected <V> io.netty.util.concurrent.Promise<V> newPromise()
```
  - newSucceededFuture
```
protected <V> io.netty.util.concurrent.Future<V> newSucceededFuture(V result)
```
  - getName
```
public String getName()
```
    Description copied from interface: RObject
    
    Returns name of object
    
    Specified by:
    
    getName in interface RObject
    
    Returns:
    name
  - rename
```
public void rename(String newName)
```
    Description copied from interface: RObject
    
    Rename current object key to newName
    
    Specified by:
    
    rename in interface RObject
  - renameAsync
```
public io.netty.util.concurrent.Future<Void> renameAsync(String newName)
```
    Description copied from interface: RObjectAsync
    
    Rename current object key to newName in async mode
    
    Specified by:
    
    renameAsync in interface RObjectAsync
    
    Returns:
  - migrate
```
public void migrate(String host,
           int port,
           int database)
```
    Description copied from interface: RObject
    
    Transfer an object from source Redis instance to destination Redis instance
    
    Specified by:
    
    migrate in interface RObject
    
    Parameters:
    host - - destination host
    port - - destination port
    database - - destination database
  - migrateAsync
```
public io.netty.util.concurrent.Future<Void> migrateAsync(String host,
                                                 int port,
                                                 int database)
```
    Description copied from interface: RObjectAsync
    
    Transfer an object from source Redis instance to destination Redis instance in async mode
    
    Specified by:
    
    migrateAsync in interface RObjectAsync
    
    Parameters:
    host - - destination host
    port - - destination port
    database - - destination database
    
    Returns:
  - move
```
public boolean move(int database)
```
    Description copied from interface: RObject
    
    Move object to another database
    
    Specified by:
    
    move in interface RObject
    
    Returns:
    true if key was moved else false
  - moveAsync
```
public io.netty.util.concurrent.Future<Boolean> moveAsync(int database)
```
    Description copied from interface: RObjectAsync
    
    Move object to another database in async mode
    
    Specified by:
    
    moveAsync in interface RObjectAsync
    
    Returns:
    true if key was moved false if not
  - renamenx
```
public boolean renamenx(String newName)
```
    Description copied from interface: RObject
    
    Rename current object key to newName only if new key is not exists
    
    Specified by:
    
    renamenx in interface RObject
    
    Returns:
  - renamenxAsync
```
public io.netty.util.concurrent.Future<Boolean> renamenxAsync(String newName)
```
    Description copied from interface: RObjectAsync
    
    Rename current object key to newName in async mode only if new key is not exists
    
    Specified by:
    
    renamenxAsync in interface RObjectAsync
    
    Returns:
  - delete
```
public boolean delete()
```
    Description copied from interface: RObject
    
    Deletes the object
    
    Specified by:
    
    delete in interface RObject
  - isExists
```
public boolean isExists()
```
    Description copied from interface: RObject
    
    Check object existence
    
    Specified by:
    
    isExists in interface RObject
    
    Returns:
    true if object exists and false otherwise
  - isExistsAsync
```
public io.netty.util.concurrent.Future<Boolean> isExistsAsync()
```
    Description copied from interface: RObjectAsync
    
    Check object existence in async mode.
    
    Specified by:
    
    isExistsAsync in interface RObjectAsync
    
    Returns:
    true if object exists and false otherwise

Class RedissonMultimap<K,V>

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.redisson.core.RMultimap

Methods inherited from interface org.redisson.core.RExpirable

Methods inherited from interface org.redisson.core.RObject

Methods inherited from interface org.redisson.core.RMultimapAsync

Methods inherited from interface org.redisson.core.RExpirableAsync

Methods inherited from interface org.redisson.core.RObjectAsync

Method Detail

hash

size

keySize

isEmpty

containsKey

containsValue

containsEntry

put

remove

putAll

clear

keySet

values

getAll

removeAll

replaceValues

entries

fastRemove

fastRemoveAsync

deleteAsync

expireAsync

expireAtAsync

clearExpireAsync

keySizeAsync

expire

expireAt

expireAt

expireAtAsync

clearExpire

remainTimeToLive

remainTimeToLiveAsync

await

get

newPromise

newSucceededFuture

getName

rename

renameAsync

migrate

migrateAsync

move

moveAsync

renamenx

renamenxAsync

delete

isExists

isExistsAsync