Type Parameters:

K - Key type.

V - Value type.

All Known Subinterfaces:

RedisAdvancedClusterAsyncCommands<K,V>, RedisAsyncCommands<K,V>, RedisClusterAsyncCommands<K,V>, RedisClusterPubSubAsyncCommands<K,V>, RedisPubSubAsyncCommands<K,V>

All Known Implementing Classes:

AbstractRedisAsyncCommands, RedisAdvancedClusterAsyncCommandsImpl, RedisAsyncCommandsImpl, RedisClusterPubSubAsyncCommandsImpl, RedisPubSubAsyncCommandsImpl
```
public interface RedisSortedSetAsyncCommands<K,V>
```
Asynchronous executed commands for Sorted Sets.

Since:

4.0

Author:

Mark Paluch

Generated class:

by io.lettuce.apigenerator.CreateAsyncApi

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method	Description
`RedisFuture<KeyValue<K,List<ScoredValue<V>>>>`	`bzmpop(double timeout, int count, ZPopArgs args, K... keys)`	Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	`bzmpop(double timeout, ZPopArgs args, K... keys)`	Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
`RedisFuture<KeyValue<K,List<ScoredValue<V>>>>`	`bzmpop(long timeout, long count, ZPopArgs args, K... keys)`	Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	`bzmpop(long timeout, ZPopArgs args, K... keys)`	Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	`bzpopmax(double timeout, K... keys)`	Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	`bzpopmax(long timeout, K... keys)`	Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	`bzpopmin(double timeout, K... keys)`	Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	`bzpopmin(long timeout, K... keys)`	Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
`RedisFuture<Long>`	`zadd(K key, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	`zadd(K key, ScoredValue<V>... scoredValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	`zadd(K key, ZAddArgs zAddArgs, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	`zadd(K key, ZAddArgs zAddArgs, ScoredValue<V>... scoredValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	`zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	`zadd(K key, Object... scoresAndValues)`	Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Double>`	`zaddincr(K key, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists applying the `INCR` option.
`RedisFuture<Double>`	`zaddincr(K key, ZAddArgs zAddArgs, double score, V member)`	Add one or more members to a sorted set, or update its score if it already exists applying the `INCR` option.
`RedisFuture<Long>`	`zcard(K key)`	Get the number of members in a sorted set.
`RedisFuture<Long>`	`zcount(K key, double min, double max)`	Deprecated. Use `zcount(java.lang.Object, Range)`.
`RedisFuture<Long>`	`zcount(K key, Range<? extends Number> range)`	Count the members in a sorted set with scores within the given `Range`.
`RedisFuture<Long>`	`zcount(K key, String min, String max)`	Deprecated. Use `zcount(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	`zdiff(K... keys)`	Computes the difference between the first and all successive input sorted sets.
`RedisFuture<Long>`	`zdiffstore(K destKey, K... srcKeys)`	Computes the difference between the first and all successive input sorted sets and stores the result in destination.
`RedisFuture<List<ScoredValue<V>>>`	`zdiffWithScores(K... keys)`	Computes the difference between the first and all successive input sorted sets.
`RedisFuture<Double>`	`zincrby(K key, double amount, V member)`	Increment the score of a member in a sorted set.
`RedisFuture<List<V>>`	`zinter(ZAggregateArgs aggregateArgs, K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`RedisFuture<List<V>>`	`zinter(K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`RedisFuture<Long>`	`zintercard(long limit, K... keys)`	This command is similar to `zinter(java.lang.Object[])`, but instead of returning the result set, it returns just the cardinality of the result.
`RedisFuture<Long>`	`zintercard(K... keys)`	This command is similar to `zinter(java.lang.Object[])`, but instead of returning the result set, it returns just the cardinality of the result.
`RedisFuture<Long>`	`zinterstore(K destination, ZStoreArgs storeArgs, K... keys)`	Intersect multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<Long>`	`zinterstore(K destination, K... keys)`	Intersect multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<List<ScoredValue<V>>>`	`zinterWithScores(ZAggregateArgs aggregateArgs, K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`RedisFuture<List<ScoredValue<V>>>`	`zinterWithScores(K... keys)`	Intersect multiple sorted sets and returns the resulting sorted.
`RedisFuture<Long>`	`zlexcount(K key, Range<? extends V> range)`	Count the number of members in a sorted set between a given lexicographical range.
`RedisFuture<Long>`	`zlexcount(K key, String min, String max)`	Deprecated. Use `zlexcount(java.lang.Object, Range)`.
`RedisFuture<KeyValue<K,List<ScoredValue<V>>>>`	`zmpop(int count, ZPopArgs args, K... keys)`	Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
`RedisFuture<KeyValue<K,ScoredValue<V>>>`	`zmpop(ZPopArgs args, K... keys)`	Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
`RedisFuture<List<Double>>`	`zmscore(K key, V... members)`	Returns the scores associated with the specified members in the sorted set stored at key.
`RedisFuture<ScoredValue<V>>`	`zpopmax(K key)`	Removes and returns up to count members with the highest scores in the sorted set stored at key.
`RedisFuture<List<ScoredValue<V>>>`	`zpopmax(K key, long count)`	Removes and returns up to count members with the highest scores in the sorted set stored at key.
`RedisFuture<ScoredValue<V>>`	`zpopmin(K key)`	Removes and returns up to count members with the lowest scores in the sorted set stored at key.
`RedisFuture<List<ScoredValue<V>>>`	`zpopmin(K key, long count)`	Removes and returns up to count members with the lowest scores in the sorted set stored at key.
`RedisFuture<V>`	`zrandmember(K key)`	Return a random member from the sorted set stored at `key`.
`RedisFuture<List<V>>`	`zrandmember(K key, long count)`	Return `count` random members from the sorted set stored at `key`.
`RedisFuture<ScoredValue<V>>`	`zrandmemberWithScores(K key)`	Return a random member along its value from the sorted set stored at `key`.
`RedisFuture<List<ScoredValue<V>>>`	`zrandmemberWithScores(K key, long count)`	Return `count` random members along their value from the sorted set stored at `key`.
`RedisFuture<Long>`	`zrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`	Return a range of members in a sorted set, by index.
`RedisFuture<List<V>>`	`zrange(K key, long start, long stop)`	Return a range of members in a sorted set, by index.
`RedisFuture<List<V>>`	`zrangebylex(K key, Range<? extends V> range)`	Return a range of members in a sorted set, by lexicographical range.
`RedisFuture<List<V>>`	`zrangebylex(K key, Range<? extends V> range, Limit limit)`	Return a range of members in a sorted set, by lexicographical range.
`RedisFuture<List<V>>`	`zrangebylex(K key, String min, String max)`	Deprecated. Use `zrangebylex(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	`zrangebylex(K key, String min, String max, long offset, long count)`	Deprecated. Use `zrangebylex(java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max)`	Deprecated. Use `zrangebyscore(ValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)`	Deprecated. Use `zrangebyscore(ValueStreamingChannel, java.lang.Object, Range, Limit limit)`.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max)`	Deprecated. Use `zrangebyscore(ValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)`	Deprecated. Use `zrangebyscore(ValueStreamingChannel, java.lang.Object, Range, Limit limit)`.
`RedisFuture<List<V>>`	`zrangebyscore(K key, double min, double max)`	Deprecated. Use `zrangebyscore(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	`zrangebyscore(K key, double min, double max, long offset, long count)`	Deprecated. Use `zrangebyscore(java.lang.Object, Range, Limit)`.
`RedisFuture<List<V>>`	`zrangebyscore(K key, Range<? extends Number> range)`	Return a range of members in a sorted set, by score.
`RedisFuture<List<V>>`	`zrangebyscore(K key, Range<? extends Number> range, Limit limit)`	Return a range of members in a sorted set, by score.
`RedisFuture<List<V>>`	`zrangebyscore(K key, String min, String max)`	Deprecated. Use `zrangebyscore(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	`zrangebyscore(K key, String min, String max, long offset, long count)`	Deprecated. Use `zrangebyscore(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max)`	Deprecated. Use `zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)`	Deprecated. Use `zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit limit)`.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members with scores in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members with scores in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max)`	Deprecated. Use `zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)`	Deprecated. Use `zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit limit)`.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, double min, double max)`	Deprecated. Use `zrangebyscoreWithScores(java.lang.Object, Range)`.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, double min, double max, long offset, long count)`	Deprecated. Use `zrangebyscoreWithScores(java.lang.Object, Range, Limit limit)`.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, Range<? extends Number> range)`	Return a range of members with score in a sorted set, by score.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)`	Return a range of members with score in a sorted set, by score.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, String min, String max)`	Deprecated. Use `zrangebyscoreWithScores(java.lang.Object, Range)`.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, String min, String max, long offset, long count)`	Deprecated. Use `zrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	`zrangestore(K dstKey, K srcKey, Range<Long> range)`	Get the specified range of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`RedisFuture<Long>`	`zrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)`	Get the specified range of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`RedisFuture<Long>`	`zrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)`	Get the specified range of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`RedisFuture<Long>`	`zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)`	Stream over a range of members with scores in a sorted set, by index.
`RedisFuture<List<ScoredValue<V>>>`	`zrangeWithScores(K key, long start, long stop)`	Return a range of members with scores in a sorted set, by index.
`RedisFuture<Long>`	`zrank(K key, V member)`	Determine the index of a member in a sorted set.
`RedisFuture<ScoredValue<Long>>`	`zrankWithScore(K key, V member)`	Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high.
`RedisFuture<Long>`	`zrem(K key, V... members)`	Remove one or more members from a sorted set.
`RedisFuture<Long>`	`zremrangebylex(K key, Range<? extends V> range)`	Remove all members in a sorted set between the given lexicographical range.
`RedisFuture<Long>`	`zremrangebylex(K key, String min, String max)`	Deprecated. Use `zremrangebylex(java.lang.Object, Range)`.
`RedisFuture<Long>`	`zremrangebyrank(K key, long start, long stop)`	Remove all members in a sorted set within the given indexes.
`RedisFuture<Long>`	`zremrangebyscore(K key, double min, double max)`	Deprecated. Use `zremrangebyscore(java.lang.Object, Range)`.
`RedisFuture<Long>`	`zremrangebyscore(K key, Range<? extends Number> range)`	Remove all members in a sorted set within the given scores.
`RedisFuture<Long>`	`zremrangebyscore(K key, String min, String max)`	Deprecated. Use `zremrangebyscore(java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop)`	Stream over a range of members in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<List<V>>`	`zrevrange(K key, long start, long stop)`	Return a range of members in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<List<V>>`	`zrevrangebylex(K key, Range<? extends V> range)`	Return a range of members in a sorted set, by lexicographical range ordered from high to low.
`RedisFuture<List<V>>`	`zrevrangebylex(K key, Range<? extends V> range, Limit limit)`	Return a range of members in a sorted set, by lexicographical range ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min)`	Deprecated. Use `zrevrangebyscore(java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)`	Deprecated. Use `zrevrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min)`	Deprecated. Use `zrevrangebyscore(java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)`	Deprecated. Use `zrevrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, double max, double min)`	Deprecated. Use `zrevrangebyscore(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, double max, double min, long offset, long count)`	Deprecated. Use `zrevrangebyscore(java.lang.Object, Range, Limit)`.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, Range<? extends Number> range)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, Range<? extends Number> range, Limit limit)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, String max, String min)`	Deprecated. Use `zrevrangebyscore(java.lang.Object, Range)`.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, String max, String min, long offset, long count)`	Deprecated. Use `zrevrangebyscore(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min)`	Deprecated. Use `zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)`	Deprecated. Use `zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit)`	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min)`	Deprecated. Use `zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range)`.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)`	Deprecated. Use `zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit)`.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, double max, double min)`	Deprecated. Use `zrevrangebyscoreWithScores(java.lang.Object, Range)`.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count)`	Deprecated. Use `zrevrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, Range<? extends Number> range)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit)`	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, String max, String min)`	Deprecated. Use `zrevrangebyscoreWithScores(java.lang.Object, Range)`.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count)`	Deprecated. Use `zrevrangebyscoreWithScores(java.lang.Object, Range, Limit)`.
`RedisFuture<Long>`	`zrevrangestore(K dstKey, K srcKey, Range<Long> range)`	Get the specified range of elements ordered from high to low in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`RedisFuture<Long>`	`zrevrangestorebylex(K dstKey, K srcKey, Range<? extends V> range, Limit limit)`	Get the lexicographical range ordered from high to low of elements in the sorted set stored at `srcKey` and stores the result in the `dstKey` destination key.
`RedisFuture<Long>`	`zrevrangestorebyscore(K dstKey, K srcKey, Range<? extends Number> range, Limit limit)`	Get the specified range of elements in the sorted set stored at {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key.
`RedisFuture<Long>`	`zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)`	Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangeWithScores(K key, long start, long stop)`	Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrank(K key, V member)`	Determine the index of a member in a sorted set, with scores ordered from high to low.
`RedisFuture<ScoredValue<Long>>`	`zrevrankWithScore(K key, V member)`	Returns the rank of member in the sorted set stored at key, with the scores ordered from high to low.
`RedisFuture<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	`zscan(K key)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	`zscan(K key, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	`zscan(K key, ScanCursor scanCursor)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	`zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)`	Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<Double>`	`zscore(K key, V member)`	Get the score associated with the given member in a sorted set.
`RedisFuture<List<V>>`	`zunion(ZAggregateArgs aggregateArgs, K... keys)`	Add multiple sorted sets and returns the resulting sorted set.
`RedisFuture<List<V>>`	`zunion(K... keys)`	Add multiple sorted sets and returns the resulting sorted set.
`RedisFuture<Long>`	`zunionstore(K destination, ZStoreArgs storeArgs, K... keys)`	Add multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<Long>`	`zunionstore(K destination, K... keys)`	Add multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<List<ScoredValue<V>>>`	`zunionWithScores(ZAggregateArgs aggregateArgs, K... keys)`	Add multiple sorted sets and returns the resulting sorted set.
`RedisFuture<List<ScoredValue<V>>>`	`zunionWithScores(K... keys)`	Add multiple sorted sets and returns the resulting sorted set.

- Method Detail
  - bzmpop
```
RedisFuture<KeyValue<K,ScoredValue<V>>> bzmpop(long timeout,
                                                     ZPopArgs args,
                                                     K... keys)
```
    Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
    
    Parameters:
    
    timeout - the timeout in seconds.
    
    keys - the keys.
    
    Returns:
    
    ScoredValue<V> the removed element or Value.empty().
    
    Since:
    
    6.3
  - bzmpop
```
RedisFuture<KeyValue<K,List<ScoredValue<V>>>> bzmpop(long timeout,
                                                           long count,
                                                           ZPopArgs args,
                                                           K... keys)
```
    Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
    
    Parameters:
    
    timeout - the timeout in seconds.
    
    count - number of elements to pop.
    
    args - the command args.
    
    keys - the keys.
    
    Returns:
    
    ScoredValue<V> the removed elements or Value.empty().
    
    Since:
    
    6.3
  - bzmpop
```
RedisFuture<KeyValue<K,ScoredValue<V>>> bzmpop(double timeout,
                                                     ZPopArgs args,
                                                     K... keys)
```
    Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
    
    Parameters:
    
    timeout - the timeout in seconds.
    
    keys - the keys.
    
    Returns:
    
    ScoredValue<V> the removed element or Value.empty().
    
    Since:
    
    6.3
  - bzmpop
```
RedisFuture<KeyValue<K,List<ScoredValue<V>>>> bzmpop(double timeout,
                                                           int count,
                                                           ZPopArgs args,
                                                           K... keys)
```
    Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
    
    Parameters:
    
    timeout - the timeout in seconds.
    
    count - number of elements to pop.
    
    args - the command args.
    
    keys - the keys.
    
    Returns:
    
    ScoredValue<V> the removed elements or Value.empty().
    
    Since:
    
    6.3
  - bzpopmin
```
RedisFuture<KeyValue<K,ScoredValue<V>>> bzpopmin(long timeout,
                                                       K... keys)
```
    Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
    
    Parameters:
    
    timeout - the timeout in seconds.
    
    keys - the keys.
    
    Returns:
    
    KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.
    
    Since:
    
    5.1
  - bzpopmin
```
RedisFuture<KeyValue<K,ScoredValue<V>>> bzpopmin(double timeout,
                                                       K... keys)
```
    Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
    
    Parameters:
    
    timeout - the timeout in seconds.
    
    keys - the keys.
    
    Returns:
    
    KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.
    
    Since:
    
    6.1.3
  - bzpopmax
```
RedisFuture<KeyValue<K,ScoredValue<V>>> bzpopmax(long timeout,
                                                       K... keys)
```
    Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
    
    Parameters:
    
    timeout - the timeout in seconds.
    
    keys - the keys.
    
    Returns:
    
    KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.
    
    Since:
    
    5.1
  - bzpopmax
```
RedisFuture<KeyValue<K,ScoredValue<V>>> bzpopmax(double timeout,
                                                       K... keys)
```
    Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
    
    Parameters:
    
    timeout - the timeout in seconds.
    
    keys - the keys.
    
    Returns:
    
    KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.
    
    Since:
    
    6.1.3
  - zadd
```
RedisFuture<Long> zadd(K key,
                       double score,
                       V member)
```
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Parameters:
    
    key - the key.
    
    score - the score.
    
    member - the member.
    
    Returns:
    
    Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zadd
```
RedisFuture<Long> zadd(K key,
                       Object... scoresAndValues)
```
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Parameters:
    
    key - the key.
    
    scoresAndValues - the scoresAndValue tuples (score,value,score,value,...).
    
    Returns:
    
    Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zadd
```
RedisFuture<Long> zadd(K key,
                       ScoredValue<V>... scoredValues)
```
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Parameters:
    
    key - the key.
    
    scoredValues - the scored values.
    
    Returns:
    
    Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zadd
```
RedisFuture<Long> zadd(K key,
                       ZAddArgs zAddArgs,
                       double score,
                       V member)
```
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Parameters:
    
    key - the key.
    
    zAddArgs - arguments for zadd.
    
    score - the score.
    
    member - the member.
    
    Returns:
    
    Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zadd
```
RedisFuture<Long> zadd(K key,
                       ZAddArgs zAddArgs,
                       Object... scoresAndValues)
```
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Parameters:
    
    key - the key.
    
    zAddArgs - arguments for zadd.
    
    scoresAndValues - the scoresAndValue tuples (score,value,score,value,...).
    
    Returns:
    
    Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zadd
```
RedisFuture<Long> zadd(K key,
                       ZAddArgs zAddArgs,
                       ScoredValue<V>... scoredValues)
```
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Parameters:
    
    key - the ke.
    
    zAddArgs - arguments for zadd.
    
    scoredValues - the scored values.
    
    Returns:
    
    Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zaddincr
```
RedisFuture<Double> zaddincr(K key,
                             double score,
                             V member)
```
    Add one or more members to a sorted set, or update its score if it already exists applying the INCR option. ZADD acts like ZINCRBY.
    
    Parameters:
    
    key - the key.
    
    score - the score.
    
    member - the member.
    
    Returns:
    
    Long integer-reply specifically: The total number of elements changed.
  - zaddincr
```
RedisFuture<Double> zaddincr(K key,
                             ZAddArgs zAddArgs,
                             double score,
                             V member)
```
    Add one or more members to a sorted set, or update its score if it already exists applying the INCR option. ZADD acts like ZINCRBY.
    
    Parameters:
    
    key - the key.
    
    zAddArgs - arguments for zadd.
    
    score - the score.
    
    member - the member.
    
    Returns:
    
    Long integer-reply specifically: The total number of elements changed.
    
    Since:
    
    4.3
  - zcard
```
RedisFuture<Long> zcard(K key)
```
    Get the number of members in a sorted set.
    
    Parameters:
    
    key - the key.
    
    Returns:
    
    Long integer-reply the cardinality (number of elements) of the sorted set, or false if key does not exist.
  - zcount
```
@Deprecated
RedisFuture<Long> zcount(K key,
                         double min,
                         double max)
```
    Deprecated.
    Use zcount(java.lang.Object, Range).
    
    Count the members in a sorted set with scores within the given values.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long integer-reply the number of elements in the specified score range.
  - zcount
```
@Deprecated
RedisFuture<Long> zcount(K key,
                         String min,
                         String max)
```
    Deprecated.
    Use zcount(java.lang.Object, Range).
    
    Count the members in a sorted set with scores within the given values.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long integer-reply the number of elements in the specified score range.
  - zcount
```
RedisFuture<Long> zcount(K key,
                         Range<? extends Number> range)
```
    Count the members in a sorted set with scores within the given Range.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    Long integer-reply the number of elements in the specified score range.
    
    Since:
    
    4.3
  - zdiff
```
RedisFuture<List<V>> zdiff(K... keys)
```
    Computes the difference between the first and all successive input sorted sets.
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of elements.
    
    Since:
    
    6.1
  - zdiffstore
```
RedisFuture<Long> zdiffstore(K destKey,
                             K... srcKeys)
```
    Computes the difference between the first and all successive input sorted sets and stores the result in destination.
    
    Parameters:
    
    destKey - the dest key.
    
    srcKeys - the src keys.
    
    Returns:
    
    Long the number of elements in the resulting sorted set at destination.
    
    Since:
    
    6.1
  - zdiffWithScores
```
RedisFuture<List<ScoredValue<V>>> zdiffWithScores(K... keys)
```
    Computes the difference between the first and all successive input sorted sets.
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of scored values.
    
    Since:
    
    6.1
  - zincrby
```
RedisFuture<Double> zincrby(K key,
                            double amount,
                            V member)
```
    Increment the score of a member in a sorted set.
    
    Parameters:
    
    key - the key.
    
    amount - the increment type: long.
    
    member - the member type: value.
    
    Returns:
    
    Double bulk-string-reply the new score of member (a double precision floating point number), represented as string.
  - zinter
```
RedisFuture<List<V>> zinter(K... keys)
```
    Intersect multiple sorted sets and returns the resulting sorted.
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of elements.
    
    Since:
    
    6.1
  - zinter
```
RedisFuture<List<V>> zinter(ZAggregateArgs aggregateArgs,
                            K... keys)
```
    Intersect multiple sorted sets and returns the resulting sorted.
    
    Parameters:
    
    aggregateArgs - arguments to define aggregation and weights.
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of elements.
    
    Since:
    
    6.1
  - zintercard
```
RedisFuture<Long> zintercard(K... keys)
```
    This command is similar to zinter(java.lang.Object[]), but instead of returning the result set, it returns just the cardinality of the result.
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    Long Integer reply the number of elements in the resulting intersection.
    
    Since:
    
    6.2
  - zintercard
```
RedisFuture<Long> zintercard(long limit,
                             K... keys)
```
    This command is similar to zinter(java.lang.Object[]), but instead of returning the result set, it returns just the cardinality of the result.
    
    Parameters:
    
    limit - If the intersection cardinality reaches limit partway through the computation, the algorithm will exit and yield limit as the cardinality
    
    keys - the keys.
    
    Returns:
    
    Long Integer reply the number of elements in the resulting intersection.
    
    Since:
    
    6.2
  - zinterWithScores
```
RedisFuture<List<ScoredValue<V>>> zinterWithScores(ZAggregateArgs aggregateArgs,
                                                   K... keys)
```
    Intersect multiple sorted sets and returns the resulting sorted.
    
    Parameters:
    
    aggregateArgs - arguments to define aggregation and weights.
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of scored values.
    
    Since:
    
    6.1
  - zinterWithScores
```
RedisFuture<List<ScoredValue<V>>> zinterWithScores(K... keys)
```
    Intersect multiple sorted sets and returns the resulting sorted.
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of scored values.
    
    Since:
    
    6.1
  - zinterstore
```
RedisFuture<Long> zinterstore(K destination,
                              K... keys)
```
    Intersect multiple sorted sets and store the resulting sorted set in a new key.
    
    Parameters:
    
    destination - the destination.
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply the number of elements in the resulting sorted set at destination.
  - zinterstore
```
RedisFuture<Long> zinterstore(K destination,
                              ZStoreArgs storeArgs,
                              K... keys)
```
    Intersect multiple sorted sets and store the resulting sorted set in a new key.
    
    Parameters:
    
    destination - the destination.
    
    storeArgs - arguments to define aggregation and weights.
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply the number of elements in the resulting sorted set at destination.
  - zlexcount
```
@Deprecated
RedisFuture<Long> zlexcount(K key,
                            String min,
                            String max)
```
    Deprecated.
    Use zlexcount(java.lang.Object, Range).
    
    Count the number of members in a sorted set between a given lexicographical range.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long integer-reply the number of elements in the specified score range.
  - zlexcount
```
RedisFuture<Long> zlexcount(K key,
                            Range<? extends V> range)
```
    Count the number of members in a sorted set between a given lexicographical range.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    Long integer-reply the number of elements in the specified score range.
    
    Since:
    
    4.3
  - zmscore
```
RedisFuture<List<Double>> zmscore(K key,
                                  V... members)
```
    Returns the scores associated with the specified members in the sorted set stored at key.
    
    Parameters:
    
    key - the key.
    
    members - the member type: value.
    
    Returns:
    
    List<Double> array-reply list of scores or nil associated with the specified member values.
    
    Since:
    
    6.1
  - zmpop
```
RedisFuture<KeyValue<K,ScoredValue<V>>> zmpop(ZPopArgs args,
                                                    K... keys)
```
    Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    ScoredValue<V> the removed element or Value.empty().
    
    Since:
    
    6.3
  - zmpop
```
RedisFuture<KeyValue<K,List<ScoredValue<V>>>> zmpop(int count,
                                                          ZPopArgs args,
                                                          K... keys)
```
    Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of keys.
    
    Parameters:
    
    count - number of elements to pop.
    
    args - the command args.
    
    keys - the keys.
    
    Returns:
    
    ScoredValue<V> the removed elements or Value.empty().
    
    Since:
    
    6.3
  - zpopmin
```
RedisFuture<ScoredValue<V>> zpopmin(K key)
```
    Removes and returns up to count members with the lowest scores in the sorted set stored at key.
    
    Parameters:
    
    key - the key.
    
    Returns:
    
    ScoredValue<V> the removed element.
    
    Since:
    
    5.1
  - zpopmin
```
RedisFuture<List<ScoredValue<V>>> zpopmin(K key,
                                          long count)
```
    Removes and returns up to count members with the lowest scores in the sorted set stored at key.
    
    Parameters:
    
    key - the key.
    
    count - the number of elements to return.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of popped scores and elements.
    
    Since:
    
    5.1
  - zpopmax
```
RedisFuture<ScoredValue<V>> zpopmax(K key)
```
    Removes and returns up to count members with the highest scores in the sorted set stored at key.
    
    Parameters:
    
    key - the key.
    
    Returns:
    
    ScoredValue<V> the removed element.
    
    Since:
    
    5.1
  - zpopmax
```
RedisFuture<List<ScoredValue<V>>> zpopmax(K key,
                                          long count)
```
    Removes and returns up to count members with the highest scores in the sorted set stored at key.
    
    Parameters:
    
    key - the key.
    
    count - the number of elements to return.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of popped scores and elements.
    
    Since:
    
    5.1
  - zrandmember
```
RedisFuture<V> zrandmember(K key)
```
    Return a random member from the sorted set stored at key.
    
    Parameters:
    
    key - the key.
    
    Returns:
    
    element.
    
    Since:
    
    6.1
  - zrandmember
```
RedisFuture<List<V>> zrandmember(K key,
                                 long count)
```
    Return count random members from the sorted set stored at key.
    
    Parameters:
    
    key - the key.
    
    count - the number of members to return. If the provided count argument is positive, return an array of distinct fields.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of scores and elements.
    
    Since:
    
    6.1
  - zrandmemberWithScores
```
RedisFuture<ScoredValue<V>> zrandmemberWithScores(K key)
```
    Return a random member along its value from the sorted set stored at key.
    
    Parameters:
    
    key - the key.
    
    Returns:
    
    the score and element.
    
    Since:
    
    6.1
  - zrandmemberWithScores
```
RedisFuture<List<ScoredValue<V>>> zrandmemberWithScores(K key,
                                                        long count)
```
    Return count random members along their value from the sorted set stored at key.
    
    Parameters:
    
    key - the key.
    
    count - the number of members to return. If the provided count argument is positive, return an array of distinct fields.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of scores and elements.
    
    Since:
    
    6.1
  - zrange
```
RedisFuture<List<V>> zrange(K key,
                            long start,
                            long stop)
```
    Return a range of members in a sorted set, by index.
    
    Parameters:
    
    key - the key.
    
    start - the start.
    
    stop - the stop.
    
    Returns:
    
    List<V> array-reply list of elements in the specified range.
  - zrange
```
RedisFuture<Long> zrange(ValueStreamingChannel<V> channel,
                         K key,
                         long start,
                         long stop)
```
    Return a range of members in a sorted set, by index.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    start - the start.
    
    stop - the stop.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrangeWithScores
```
RedisFuture<List<ScoredValue<V>>> zrangeWithScores(K key,
                                                   long start,
                                                   long stop)
```
    Return a range of members with scores in a sorted set, by index.
    
    Parameters:
    
    key - the key.
    
    start - the start.
    
    stop - the stop.
    
    Returns:
    
    List<V> array-reply list of elements in the specified range.
  - zrangeWithScores
```
RedisFuture<Long> zrangeWithScores(ScoredValueStreamingChannel<V> channel,
                                   K key,
                                   long start,
                                   long stop)
```
    Stream over a range of members with scores in a sorted set, by index.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    start - the start.
    
    stop - the stop.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrangebylex
```
@Deprecated
RedisFuture<List<V>> zrangebylex(K key,
                                 String min,
                                 String max)
```
    Deprecated.
    Use zrangebylex(java.lang.Object, Range).
    
    Return a range of members in a sorted set, by lexicographical range.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    List<V> array-reply list of elements in the specified range.
  - zrangebylex
```
RedisFuture<List<V>> zrangebylex(K key,
                                 Range<? extends V> range)
```
    Return a range of members in a sorted set, by lexicographical range.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    List<V> array-reply list of elements in the specified range.
    
    Since:
    
    4.3
  - zrangebylex
```
@Deprecated
RedisFuture<List<V>> zrangebylex(K key,
                                 String min,
                                 String max,
                                 long offset,
                                 long count)
```
    Deprecated.
    Use zrangebylex(java.lang.Object, Range).
    
    Return a range of members in a sorted set, by lexicographical range.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    List<V> array-reply list of elements in the specified range.
  - zrangebylex
```
RedisFuture<List<V>> zrangebylex(K key,
                                 Range<? extends V> range,
                                 Limit limit)
```
    Return a range of members in a sorted set, by lexicographical range.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    limit - the limit.
    
    Returns:
    
    List<V> array-reply list of elements in the specified range.
    
    Since:
    
    4.3
  - zrangebyscore
```
@Deprecated
RedisFuture<List<V>> zrangebyscore(K key,
                                   double min,
                                   double max)
```
    Deprecated.
    Use zrangebyscore(java.lang.Object, Range).
    
    Return a range of members in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrangebyscore
```
@Deprecated
RedisFuture<List<V>> zrangebyscore(K key,
                                   String min,
                                   String max)
```
    Deprecated.
    Use zrangebyscore(java.lang.Object, Range).
    
    Return a range of members in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrangebyscore
```
RedisFuture<List<V>> zrangebyscore(K key,
                                   Range<? extends Number> range)
```
    Return a range of members in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrangebyscore
```
@Deprecated
RedisFuture<List<V>> zrangebyscore(K key,
                                   double min,
                                   double max,
                                   long offset,
                                   long count)
```
    Deprecated.
    Use zrangebyscore(java.lang.Object, Range, Limit).
    
    Return a range of members in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrangebyscore
```
@Deprecated
RedisFuture<List<V>> zrangebyscore(K key,
                                   String min,
                                   String max,
                                   long offset,
                                   long count)
```
    Deprecated.
    Use zrangebyscore(java.lang.Object, Range, Limit).
    
    Return a range of members in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrangebyscore
```
RedisFuture<List<V>> zrangebyscore(K key,
                                   Range<? extends Number> range,
                                   Limit limit)
```
    Return a range of members in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    limit - the limit.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrangebyscore
```
@Deprecated
RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                K key,
                                double min,
                                double max)
```
    Deprecated.
    Use zrangebyscore(ValueStreamingChannel, java.lang.Object, Range).
    
    Stream over a range of members in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long count of elements in the specified score range.
  - zrangebyscore
```
@Deprecated
RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                K key,
                                String min,
                                String max)
```
    Deprecated.
    Use zrangebyscore(ValueStreamingChannel, java.lang.Object, Range).
    
    Stream over a range of members in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long count of elements in the specified score range.
  - zrangebyscore
```
RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                K key,
                                Range<? extends Number> range)
```
    Stream over a range of members in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    Long count of elements in the specified score range.
    
    Since:
    
    4.3
  - zrangebyscore
```
@Deprecated
RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                K key,
                                double min,
                                double max,
                                long offset,
                                long count)
```
    Deprecated.
    Use zrangebyscore(ValueStreamingChannel, java.lang.Object, Range, Limit limit).
    
    Stream over range of members in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    Long count of elements in the specified score range.
  - zrangebyscore
```
@Deprecated
RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                K key,
                                String min,
                                String max,
                                long offset,
                                long count)
```
    Deprecated.
    Use zrangebyscore(ValueStreamingChannel, java.lang.Object, Range, Limit limit).
    
    Stream over a range of members in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    Long count of elements in the specified score range.
  - zrangebyscore
```
RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                K key,
                                Range<? extends Number> range,
                                Limit limit)
```
    Stream over a range of members in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    range - the range.
    
    limit - the limit.
    
    Returns:
    
    Long count of elements in the specified score range.
    
    Since:
    
    4.3
  - zrangebyscoreWithScores
```
@Deprecated
RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                          double min,
                                                          double max)
```
    Deprecated.
    Use zrangebyscoreWithScores(java.lang.Object, Range).
    
    Return a range of members with score in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of elements in the specified score range.
  - zrangebyscoreWithScores
```
@Deprecated
RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                          String min,
                                                          String max)
```
    Deprecated.
    Use zrangebyscoreWithScores(java.lang.Object, Range).
    
    Return a range of members with score in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of elements in the specified score range.
  - zrangebyscoreWithScores
```
RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                          Range<? extends Number> range)
```
    Return a range of members with score in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrangebyscoreWithScores
```
@Deprecated
RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                          double min,
                                                          double max,
                                                          long offset,
                                                          long count)
```
    Deprecated.
    Use zrangebyscoreWithScores(java.lang.Object, Range, Limit limit).
    
    Return a range of members with score in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of elements in the specified score range.
  - zrangebyscoreWithScores
```
@Deprecated
RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                          String min,
                                                          String max,
                                                          long offset,
                                                          long count)
```
    Deprecated.
    Use zrangebyscoreWithScores(java.lang.Object, Range, Limit).
    
    Return a range of members with score in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of elements in the specified score range.
  - zrangebyscoreWithScores
```
RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                          Range<? extends Number> range,
                                                          Limit limit)
```
    Return a range of members with score in a sorted set, by score.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    limit - the limit.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrangebyscoreWithScores
```
@Deprecated
RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                          K key,
                                          double min,
                                          double max)
```
    Deprecated.
    Use zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range).
    
    Stream over a range of members with scores in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long count of elements in the specified score range.
  - zrangebyscoreWithScores
```
@Deprecated
RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                          K key,
                                          String min,
                                          String max)
```
    Deprecated.
    Use zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range).
    
    Stream over a range of members with scores in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long count of elements in the specified score range.
  - zrangebyscoreWithScores
```
RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                          K key,
                                          Range<? extends Number> range)
```
    Stream over a range of members with scores in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    Long count of elements in the specified score range.
    
    Since:
    
    4.3
  - zrangebyscoreWithScores
```
@Deprecated
RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                          K key,
                                          double min,
                                          double max,
                                          long offset,
                                          long count)
```
    Deprecated.
    Use zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit limit).
    
    Stream over a range of members with scores in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    Long count of elements in the specified score range.
  - zrangebyscoreWithScores
```
@Deprecated
RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                          K key,
                                          String min,
                                          String max,
                                          long offset,
                                          long count)
```
    Deprecated.
    Use zrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit limit).
    
    Stream over a range of members with scores in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    Long count of elements in the specified score range.
  - zrangebyscoreWithScores
```
RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                          K key,
                                          Range<? extends Number> range,
                                          Limit limit)
```
    Stream over a range of members with scores in a sorted set, by score.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    range - the range.
    
    limit - the limit.
    
    Returns:
    
    Long count of elements in the specified score range.
    
    Since:
    
    4.3
  - zrangestore
```
RedisFuture<Long> zrangestore(K dstKey,
                              K srcKey,
                              Range<Long> range)
```
    Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
    
    Parameters:
    
    dstKey - the dst key.
    
    srcKey - the src key.
    
    range - the rank.
    
    Returns:
    
    the number of elements in the resulting sorted set.
    
    Since:
    
    6.2.1
  - zrangestorebylex
```
RedisFuture<Long> zrangestorebylex(K dstKey,
                                   K srcKey,
                                   Range<? extends V> range,
                                   Limit limit)
```
    Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
    
    Parameters:
    
    dstKey - the dst key.
    
    srcKey - the src key.
    
    range - the lexicographical range.
    
    limit - the limit to apply.
    
    Returns:
    
    the number of elements in the resulting sorted set.
    
    Since:
    
    6.1
  - zrangestorebyscore
```
RedisFuture<Long> zrangestorebyscore(K dstKey,
                                     K srcKey,
                                     Range<? extends Number> range,
                                     Limit limit)
```
    Get the specified range of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
    
    Parameters:
    
    dstKey - the dst key.
    
    srcKey - the src key.
    
    range - the score range.
    
    limit - the limit to apply.
    
    Returns:
    
    the number of elements in the resulting sorted set.
    
    Since:
    
    6.1
  - zrank
```
RedisFuture<Long> zrank(K key,
                        V member)
```
    Determine the index of a member in a sorted set.
    
    Parameters:
    
    key - the key.
    
    member - the member type: value.
    
    Returns:
    
    Long integer-reply the rank of member. If member does not exist in the sorted set or key does not exist,.
  - zrankWithScore
```
RedisFuture<ScoredValue<Long>> zrankWithScore(K key,
                                              V member)
```
    Returns the rank of member in the sorted set stored at key, with the scores ordered from low to high.
    
    Parameters:
    
    key - the key.
    
    member - the member type: value.
    
    Returns:
    
    the rank and score
    
    Since:
    
    6.3
  - zrem
```
RedisFuture<Long> zrem(K key,
                       V... members)
```
    Remove one or more members from a sorted set.
    
    Parameters:
    
    key - the key.
    
    members - the member type: value.
    
    Returns:
    
    Long integer-reply specifically: The number of members removed from the sorted set, not including non existing members.
  - zremrangebylex
```
@Deprecated
RedisFuture<Long> zremrangebylex(K key,
                                 String min,
                                 String max)
```
    Deprecated.
    Use zremrangebylex(java.lang.Object, Range).
    
    Remove all members in a sorted set between the given lexicographical range.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long integer-reply the number of elements removed.
  - zremrangebylex
```
RedisFuture<Long> zremrangebylex(K key,
                                 Range<? extends V> range)
```
    Remove all members in a sorted set between the given lexicographical range.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    Long integer-reply the number of elements removed.
    
    Since:
    
    4.3
  - zremrangebyrank
```
RedisFuture<Long> zremrangebyrank(K key,
                                  long start,
                                  long stop)
```
    Remove all members in a sorted set within the given indexes.
    
    Parameters:
    
    key - the key.
    
    start - the start type: long.
    
    stop - the stop type: long.
    
    Returns:
    
    Long integer-reply the number of elements removed.
  - zremrangebyscore
```
@Deprecated
RedisFuture<Long> zremrangebyscore(K key,
                                   double min,
                                   double max)
```
    Deprecated.
    Use zremrangebyscore(java.lang.Object, Range).
    
    Remove all members in a sorted set within the given scores.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long integer-reply the number of elements removed.
  - zremrangebyscore
```
@Deprecated
RedisFuture<Long> zremrangebyscore(K key,
                                   String min,
                                   String max)
```
    Deprecated.
    Use zremrangebyscore(java.lang.Object, Range).
    
    Remove all members in a sorted set within the given scores.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long integer-reply the number of elements removed.
  - zremrangebyscore
```
RedisFuture<Long> zremrangebyscore(K key,
                                   Range<? extends Number> range)
```
    Remove all members in a sorted set within the given scores.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    Long integer-reply the number of elements removed.
    
    Since:
    
    4.3
  - zrevrange
```
RedisFuture<List<V>> zrevrange(K key,
                               long start,
                               long stop)
```
    Return a range of members in a sorted set, by index, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    start - the start.
    
    stop - the stop.
    
    Returns:
    
    List<V> array-reply list of elements in the specified range.
  - zrevrange
```
RedisFuture<Long> zrevrange(ValueStreamingChannel<V> channel,
                            K key,
                            long start,
                            long stop)
```
    Stream over a range of members in a sorted set, by index, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    start - the start.
    
    stop - the stop.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangeWithScores
```
RedisFuture<List<ScoredValue<V>>> zrevrangeWithScores(K key,
                                                      long start,
                                                      long stop)
```
    Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    start - the start.
    
    stop - the stop.
    
    Returns:
    
    List<V> array-reply list of elements in the specified range.
  - zrevrangeWithScores
```
RedisFuture<Long> zrevrangeWithScores(ScoredValueStreamingChannel<V> channel,
                                      K key,
                                      long start,
                                      long stop)
```
    Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    start - the start.
    
    stop - the stop.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebylex
```
RedisFuture<List<V>> zrevrangebylex(K key,
                                    Range<? extends V> range)
```
    Return a range of members in a sorted set, by lexicographical range ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrevrangebylex
```
RedisFuture<List<V>> zrevrangebylex(K key,
                                    Range<? extends V> range,
                                    Limit limit)
```
    Return a range of members in a sorted set, by lexicographical range ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    limit - the limit.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrevrangebyscore
```
@Deprecated
RedisFuture<List<V>> zrevrangebyscore(K key,
                                      double max,
                                      double min)
```
    Deprecated.
    Use zrevrangebyscore(java.lang.Object, Range).
    
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrevrangebyscore
```
@Deprecated
RedisFuture<List<V>> zrevrangebyscore(K key,
                                      String max,
                                      String min)
```
    Deprecated.
    Use zrevrangebyscore(java.lang.Object, Range).
    
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrevrangebyscore
```
RedisFuture<List<V>> zrevrangebyscore(K key,
                                      Range<? extends Number> range)
```
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrevrangebyscore
```
@Deprecated
RedisFuture<List<V>> zrevrangebyscore(K key,
                                      double max,
                                      double min,
                                      long offset,
                                      long count)
```
    Deprecated.
    Use zrevrangebyscore(java.lang.Object, Range, Limit).
    
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    max - max score.
    
    min - min score.
    
    offset - the withscores.
    
    count - the number of items.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrevrangebyscore
```
@Deprecated
RedisFuture<List<V>> zrevrangebyscore(K key,
                                      String max,
                                      String min,
                                      long offset,
                                      long count)
```
    Deprecated.
    Use zrevrangebyscore(java.lang.Object, Range, Limit).
    
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    max - max score.
    
    min - min score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrevrangebyscore
```
RedisFuture<List<V>> zrevrangebyscore(K key,
                                      Range<? extends Number> range,
                                      Limit limit)
```
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    limit - the limit.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrevrangebyscore
```
@Deprecated
RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                   K key,
                                   double max,
                                   double min)
```
    Deprecated.
    Use zrevrangebyscore(java.lang.Object, Range).
    
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    max - max score.
    
    min - min score.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebyscore
```
@Deprecated
RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                   K key,
                                   String max,
                                   String min)
```
    Deprecated.
    Use zrevrangebyscore(java.lang.Object, Range).
    
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebyscore
```
RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                   K key,
                                   Range<? extends Number> range)
```
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    Long count of elements in the specified range.
    
    Since:
    
    4.3
  - zrevrangebyscore
```
@Deprecated
RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                   K key,
                                   double max,
                                   double min,
                                   long offset,
                                   long count)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(java.lang.Object, Range, Limit).
    
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebyscore
```
@Deprecated
RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                   K key,
                                   String max,
                                   String min,
                                   long offset,
                                   long count)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(java.lang.Object, Range, Limit).
    
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebyscore
```
RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                   K key,
                                   Range<? extends Number> range,
                                   Limit limit)
```
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every value.
    
    key - the key.
    
    range - the range.
    
    limit - the limit.
    
    Returns:
    
    Long count of elements in the specified range.
    
    Since:
    
    4.3
  - zrevrangebyscoreWithScores
```
@Deprecated
RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                             double max,
                                                             double min)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(java.lang.Object, Range).
    
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    max - max score.
    
    min - min score.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrevrangebyscoreWithScores
```
@Deprecated
RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                             String max,
                                                             String min)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(java.lang.Object, Range).
    
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    max - max score.
    
    min - min score.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of elements in the specified score range.
  - zrevrangebyscoreWithScores
```
RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                             Range<? extends Number> range)
```
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrevrangebyscoreWithScores
```
@Deprecated
RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                             double max,
                                                             double min,
                                                             long offset,
                                                             long count)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(java.lang.Object, Range, Limit).
    
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    max - max score.
    
    min - min score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    List<ScoredValue<V>> array-reply list of elements in the specified score range.
  - zrevrangebyscoreWithScores
```
@Deprecated
RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                             String max,
                                                             String min,
                                                             long offset,
                                                             long count)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(java.lang.Object, Range, Limit).
    
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    max - max score.
    
    min - min score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
  - zrevrangebyscoreWithScores
```
RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                             Range<? extends Number> range,
                                                             Limit limit)
```
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    range - the range.
    
    limit - limit.
    
    Returns:
    
    List<V> array-reply list of elements in the specified score range.
    
    Since:
    
    4.3
  - zrevrangebyscoreWithScores
```
@Deprecated
RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                             K key,
                                             double max,
                                             double min)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range).
    
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebyscoreWithScores
```
@Deprecated
RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                             K key,
                                             String max,
                                             String min)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range).
    
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebyscoreWithScores
```
RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                             K key,
                                             Range<? extends Number> range)
```
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    range - the range.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebyscoreWithScores
```
@Deprecated
RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                             K key,
                                             double max,
                                             double min,
                                             long offset,
                                             long count)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit).
    
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebyscoreWithScores
```
@Deprecated
RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                             K key,
                                             String max,
                                             String min,
                                             long offset,
                                             long count)
```
    Deprecated.
    Use zrevrangebyscoreWithScores(ScoredValueStreamingChannel, java.lang.Object, Range, Limit).
    
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    min - min score.
    
    max - max score.
    
    offset - the offset.
    
    count - the count.
    
    Returns:
    
    Long count of elements in the specified range.
  - zrevrangebyscoreWithScores
```
RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                             K key,
                                             Range<? extends Number> range,
                                             Limit limit)
```
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    range - the range.
    
    limit - the limit.
    
    Returns:
    
    Long count of elements in the specified range.
    
    Since:
    
    4.3
  - zrevrangestore
```
RedisFuture<Long> zrevrangestore(K dstKey,
                                 K srcKey,
                                 Range<Long> range)
```
    Get the specified range of elements ordered from high to low in the sorted set stored at srcKey and stores the result in the dstKey destination key.
    
    Parameters:
    
    dstKey - the dst key.
    
    srcKey - the src key.
    
    range - the rank.
    
    Returns:
    
    the number of elements in the resulting sorted set.
    
    Since:
    
    6.2.1
  - zrevrangestorebylex
```
RedisFuture<Long> zrevrangestorebylex(K dstKey,
                                      K srcKey,
                                      Range<? extends V> range,
                                      Limit limit)
```
    Get the lexicographical range ordered from high to low of elements in the sorted set stored at srcKey and stores the result in the dstKey destination key.
    
    Parameters:
    
    dstKey - the src key.
    
    srcKey - the dst key.
    
    range - the lexicographical range.
    
    limit - the limit to apply.
    
    Returns:
    
    the number of elements in the resulting sorted set.
    
    Since:
    
    6.1
  - zrevrangestorebyscore
```
RedisFuture<Long> zrevrangestorebyscore(K dstKey,
                                        K srcKey,
                                        Range<? extends Number> range,
                                        Limit limit)
```
    Get the specified range of elements in the sorted set stored at {@code srcKey with scores ordered from high to low and stores the result in the {@code dstKey} destination key.
    
    Parameters:
    
    dstKey - the src key.
    
    srcKey - the dst key.
    
    range - the score range.
    
    limit - the limit to apply.
    
    Returns:
    
    the number of elements in the resulting sorted set.
    
    Since:
    
    6.1
  - zrevrank
```
RedisFuture<Long> zrevrank(K key,
                           V member)
```
    Determine the index of a member in a sorted set, with scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    member - the member type: value.
    
    Returns:
    
    Long integer-reply the rank of member. If member does not exist in the sorted set or key does not exist return null.
  - zrevrankWithScore
```
RedisFuture<ScoredValue<Long>> zrevrankWithScore(K key,
                                                 V member)
```
    Returns the rank of member in the sorted set stored at key, with the scores ordered from high to low.
    
    Parameters:
    
    key - the key.
    
    member - the member type: value.
    
    Returns:
    
    the rank and score
    
    Since:
    
    6.3
  - zscan
```
RedisFuture<ScoredValueScanCursor<V>> zscan(K key)
```
    Incrementally iterate sorted sets elements and associated scores.
    
    Parameters:
    
    key - the key.
    
    Returns:
    
    ScoredValueScanCursor<V> scan cursor.
  - zscan
```
RedisFuture<ScoredValueScanCursor<V>> zscan(K key,
                                            ScanArgs scanArgs)
```
    Incrementally iterate sorted sets elements and associated scores.
    
    Parameters:
    
    key - the key.
    
    scanArgs - scan arguments.
    
    Returns:
    
    ScoredValueScanCursor<V> scan cursor.
  - zscan
```
RedisFuture<ScoredValueScanCursor<V>> zscan(K key,
                                            ScanCursor scanCursor,
                                            ScanArgs scanArgs)
```
    Incrementally iterate sorted sets elements and associated scores.
    
    Parameters:
    
    key - the key.
    
    scanCursor - cursor to resume from a previous scan, must not be null.
    
    scanArgs - scan arguments.
    
    Returns:
    
    ScoredValueScanCursor<V> scan cursor.
  - zscan
```
RedisFuture<ScoredValueScanCursor<V>> zscan(K key,
                                            ScanCursor scanCursor)
```
    Incrementally iterate sorted sets elements and associated scores.
    
    Parameters:
    
    key - the key.
    
    scanCursor - cursor to resume from a previous scan, must not be null.
    
    Returns:
    
    ScoredValueScanCursor<V> scan cursor.
  - zscan
```
RedisFuture<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel,
                                    K key)
```
    Incrementally iterate sorted sets elements and associated scores.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    Returns:
    
    StreamScanCursor scan cursor.
  - zscan
```
RedisFuture<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel,
                                    K key,
                                    ScanArgs scanArgs)
```
    Incrementally iterate sorted sets elements and associated scores.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    scanArgs - scan arguments.
    
    Returns:
    
    StreamScanCursor scan cursor.
  - zscan
```
RedisFuture<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel,
                                    K key,
                                    ScanCursor scanCursor,
                                    ScanArgs scanArgs)
```
    Incrementally iterate sorted sets elements and associated scores.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    scanCursor - cursor to resume from a previous scan, must not be null.
    
    scanArgs - scan arguments.
    
    Returns:
    
    StreamScanCursor scan cursor.
  - zscan
```
RedisFuture<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel,
                                    K key,
                                    ScanCursor scanCursor)
```
    Incrementally iterate sorted sets elements and associated scores.
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value.
    
    key - the key.
    
    scanCursor - cursor to resume from a previous scan, must not be null.
    
    Returns:
    
    StreamScanCursor scan cursor.
  - zscore
```
RedisFuture<Double> zscore(K key,
                           V member)
```
    Get the score associated with the given member in a sorted set.
    
    Parameters:
    
    key - the key.
    
    member - the member type: value.
    
    Returns:
    
    Double bulk-string-reply the score of member (a double precision floating point number), represented as string.
  - zunion
```
RedisFuture<List<V>> zunion(K... keys)
```
    Add multiple sorted sets and returns the resulting sorted set.
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of elements.
    
    Since:
    
    6.1
  - zunion
```
RedisFuture<List<V>> zunion(ZAggregateArgs aggregateArgs,
                            K... keys)
```
    Add multiple sorted sets and returns the resulting sorted set.
    
    Parameters:
    
    aggregateArgs - arguments to define aggregation and weights.
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of elements.
    
    Since:
    
    6.1
  - zunionWithScores
```
RedisFuture<List<ScoredValue<V>>> zunionWithScores(ZAggregateArgs aggregateArgs,
                                                   K... keys)
```
    Add multiple sorted sets and returns the resulting sorted set.
    
    Parameters:
    
    aggregateArgs - arguments to define aggregation and weights.
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of scored values.
    
    Since:
    
    6.1
  - zunionWithScores
```
RedisFuture<List<ScoredValue<V>>> zunionWithScores(K... keys)
```
    Add multiple sorted sets and returns the resulting sorted set.
    
    Parameters:
    
    keys - the keys.
    
    Returns:
    
    List<V> array-reply list of scored values.
    
    Since:
    
    6.1
  - zunionstore
```
RedisFuture<Long> zunionstore(K destination,
                              K... keys)
```
    Add multiple sorted sets and store the resulting sorted set in a new key.
    
    Parameters:
    
    destination - destination key.
    
    keys - source keys.
    
    Returns:
    
    Long integer-reply the number of elements in the resulting sorted set at destination.
  - zunionstore
```
RedisFuture<Long> zunionstore(K destination,
                              ZStoreArgs storeArgs,
                              K... keys)
```
    Add multiple sorted sets and store the resulting sorted set in a new key.
    
    Parameters:
    
    destination - the destination.
    
    storeArgs - arguments to define aggregation and weights.
    
    keys - the keys.
    
    Returns:
    
    Long integer-reply the number of elements in the resulting sorted set at destination.

Interface RedisSortedSetAsyncCommands<K,​V>

Method Summary

Method Detail

bzmpop

bzmpop

bzmpop

bzmpop

bzpopmin

bzpopmin

bzpopmax

bzpopmax

zadd

zadd

zadd

zadd

zadd

zadd

zaddincr

zaddincr

zcard

zcount

zcount

zcount

zdiff

zdiffstore

zdiffWithScores

zincrby

zinter

zinter

zintercard

zintercard

zinterWithScores

zinterWithScores

zinterstore

zinterstore

zlexcount

zlexcount

zmscore

zmpop

zmpop

zpopmin

zpopmin

zpopmax

zpopmax

zrandmember

zrandmember

zrandmemberWithScores

zrandmemberWithScores

zrange

zrange

zrangeWithScores

zrangeWithScores

zrangebylex

zrangebylex

zrangebylex

zrangebylex

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscore

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

zrangebyscoreWithScores

Interface RedisSortedSetAsyncCommands<K,V>