com.buession.redis.client.jedis.operations

类 JedisSortedSetOperations

java.lang.Object

com.buession.redis.client.operations.AbstractRedisOperations<C>

com.buession.redis.client.jedis.operations.AbstractJedisRedisOperations<C>

com.buession.redis.client.jedis.operations.AbstractSortedSetOperations<JedisStandaloneClient>

com.buession.redis.client.jedis.operations.JedisSortedSetOperations

所有已实现的接口:

JedisRedisOperations, RedisOperations, SortedSetOperations, RedisCommands, SortedSetCommands

public final class JedisSortedSetOperations
extends AbstractSortedSetOperations<JedisStandaloneClient>

Jedis 单机模式模式有序集合命令操作

从以下版本开始:

2.0.0

作者:

Yong.Teng

嵌套类概要

从接口继承的嵌套类/接口 com.buession.redis.client.jedis.operations.JedisRedisOperations

JedisRedisOperations.AbstractJedisCommand<CLIENT extends JedisRedisClient,CONN extends JedisRedisConnection,R>, JedisRedisOperations.JedisClusterCommand<R>, JedisRedisOperations.JedisCommand<R>, JedisRedisOperations.JedisSentinelCommand<R>

字段概要

从类继承的字段 com.buession.redis.client.jedis.operations.AbstractJedisRedisOperations

client

从类继承的字段 com.buession.redis.client.operations.AbstractRedisOperations

logger

构造器概要

构造器

构造器和说明
JedisSortedSetOperations(JedisStandaloneClient client)

方法概要

限定符和类型	方法和说明
KeyedZSetElement	bzPopMax(byte[][] keys, int timeout) 从非空的第一个有序集中弹出得分最高的成员，按照命令中 key 出现的顺序检查；是有序集 ZPOPMAX 的阻塞变体； 当没有成员可以从任何给定的有序集中弹出时，它会阻塞连接 详情说明 https://www.redis.com.cn/commands/bzpopmax.html
KeyedZSetElement	bzPopMax(String[] keys, int timeout) 从非空的第一个有序集中弹出得分最高的成员，按照命令中 key 出现的顺序检查；是有序集 ZPOPMAX 的阻塞变体； 当没有成员可以从任何给定的有序集中弹出时，它会阻塞连接 详情说明 https://www.redis.com.cn/commands/bzpopmax.html
KeyedZSetElement	bzPopMin(byte[][] keys, int timeout) 从非空的第一个有序集中弹出得分最小的成员，按照命令中 key 出现的顺序检查；是有序集 ZPOPMIN 的阻塞变体； 当没有成员可以从任何给定的有序集中弹出时，它会阻塞连接 详情说明 https://www.redis.com.cn/commands/bzpopmin.html
KeyedZSetElement	bzPopMin(String[] keys, int timeout) 从非空的第一个有序集中弹出得分最小的成员，按照命令中 key 出现的顺序检查；是有序集 ZPOPMIN 的阻塞变体； 当没有成员可以从任何给定的有序集中弹出时，它会阻塞连接 详情说明 https://www.redis.com.cn/commands/bzpopmin.html
Long	zAdd(byte[] key, Map<byte[],Double> members) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
Long	zAdd(byte[] key, Map<byte[],Double> members, boolean ch) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
Long	zAdd(byte[] key, Map<byte[],Double> members, GtLt gtLt) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
Long	zAdd(byte[] key, Map<byte[],Double> members, GtLt gtLt, boolean ch) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
Long	zAdd(byte[] key, Map<byte[],Double> members, NxXx nxXx) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
Long	zAdd(byte[] key, Map<byte[],Double> members, NxXx nxXx, boolean ch) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
Long	zAdd(byte[] key, Map<byte[],Double> members, NxXx nxXx, GtLt gtLt) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
Long	zAdd(byte[] key, Map<byte[],Double> members, NxXx nxXx, GtLt gtLt, boolean ch) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
Long	zAdd(String key, Map<String,Double> members) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
Long	zAdd(String key, Map<String,Double> members, boolean ch) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
Long	zAdd(String key, Map<String,Double> members, GtLt gtLt) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
Long	zAdd(String key, Map<String,Double> members, GtLt gtLt, boolean ch) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
Long	zAdd(String key, Map<String,Double> members, NxXx nxXx) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
Long	zAdd(String key, Map<String,Double> members, NxXx nxXx, boolean ch) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
Long	zAdd(String key, Map<String,Double> members, NxXx nxXx, GtLt gtLt) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
Long	zAdd(String key, Map<String,Double> members, NxXx nxXx, GtLt gtLt, boolean ch) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
Long	zCard(byte[] key) 获取有序集 key 的基数 详情说明 http://redisdoc.com/sorted_set/zcard.html
Long	zCard(String key) 获取有序集 key 的基数 详情说明 http://redisdoc.com/sorted_set/zcard.html
Long	zCount(byte[] key, byte[] min, byte[] max) 获取有序集 key 中，score 值在 min 和 max 之间（包括 score 值等于 min 或 max ）的成员的数量 详情说明 http://redisdoc.com/sorted_set/zcount.html
Long	zCount(byte[] key, double min, double max) 获取有序集 key 中，score 值在 min 和 max 之间（包括 score 值等于 min 或 max ）的成员的数量 详情说明 http://redisdoc.com/sorted_set/zcount.html
Long	zCount(String key, double min, double max) 获取有序集 key 中，score 值在 min 和 max 之间（包括 score 值等于 min 或 max ）的成员的数量 详情说明 http://redisdoc.com/sorted_set/zcount.html
Long	zCount(String key, String min, String max) 获取有序集 key 中，score 值在 min 和 max 之间（包括 score 值等于 min 或 max ）的成员的数量 详情说明 http://redisdoc.com/sorted_set/zcount.html
Set<byte[]>	zDiff(byte[]... keys) This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client 详情说明 https://redis.io/commands/zdiff/
Set<String>	zDiff(String... keys) This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client 详情说明 https://redis.io/commands/zdiff/
Long	zDiffStore(byte[] destKey, byte[]... keys) Computes the difference between the first and all successive input sorted sets and stores the result in destination 详情说明 https://redis.io/commands/zdiffstore/
Long	zDiffStore(String destKey, String... keys) Computes the difference between the first and all successive input sorted sets and stores the result in destination 详情说明 https://redis.io/commands/zdiffstore/
Set<Tuple>	zDiffWithScores(byte[]... keys) This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client 详情说明 https://redis.io/commands/zdiff/
Set<Tuple>	zDiffWithScores(String... keys) This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client 详情说明 https://redis.io/commands/zdiff/
Double	zIncrBy(byte[] key, double increment, byte[] member) 为有序集 key 的成员 member 的 score 值加上增量 increment 详情说明 http://redisdoc.com/sorted_set/zincrby.html
Double	zIncrBy(String key, double increment, String member) 为有序集 key 的成员 member 的 score 值加上增量 increment 详情说明 http://redisdoc.com/sorted_set/zincrby.html
Set<byte[]>	zInter(byte[]... keys) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<byte[]>	zInter(byte[][] keys, Aggregate aggregate) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<byte[]>	zInter(byte[][] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<byte[]>	zInter(byte[][] keys, double... weights) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<String>	zInter(String... keys) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<String>	zInter(String[] keys, Aggregate aggregate) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<String>	zInter(String[] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<String>	zInter(String[] keys, double... weights) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Long	zInterStore(byte[] destKey, byte[]... keys) 计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中 详情说明 http://redisdoc.com/sorted_set/zinterstore.html
Long	zInterStore(byte[] destKey, byte[][] keys, Aggregate aggregate) 计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中 详情说明 http://redisdoc.com/sorted_set/zinterstore.html
Long	zInterStore(byte[] destKey, byte[][] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中 详情说明 http://redisdoc.com/sorted_set/zinterstore.html
Long	zInterStore(byte[] destKey, byte[][] keys, double... weights) 计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中 详情说明 http://redisdoc.com/sorted_set/zinterstore.html
Long	zInterStore(String destKey, String... keys) 计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中 详情说明 http://redisdoc.com/sorted_set/zinterstore.html
Long	zInterStore(String destKey, String[] keys, Aggregate aggregate) 计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中 详情说明 http://redisdoc.com/sorted_set/zinterstore.html
Long	zInterStore(String destKey, String[] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中 详情说明 http://redisdoc.com/sorted_set/zinterstore.html
Long	zInterStore(String destKey, String[] keys, double... weights) 计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中 详情说明 http://redisdoc.com/sorted_set/zinterstore.html
Set<Tuple>	zInterWithScores(byte[]... keys) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<Tuple>	zInterWithScores(byte[][] keys, Aggregate aggregate) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<Tuple>	zInterWithScores(byte[][] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<Tuple>	zInterWithScores(byte[][] keys, double... weights) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<Tuple>	zInterWithScores(String... keys) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<Tuple>	zInterWithScores(String[] keys, Aggregate aggregate) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<Tuple>	zInterWithScores(String[] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Set<Tuple>	zInterWithScores(String[] keys, double... weights) 计算给定的一个或多个有序集合的交集 详情说明 https://redis.io/commands/zinter/
Long	zLexCount(byte[] key, byte[] min, byte[] max) 获取集合 Key 中，成员介于 min 和 max 范围内的元素数量 详情说明 http://redisdoc.com/sorted_set/zlexcount.html
Long	zLexCount(byte[] key, double min, double max) 获取集合 Key 中，成员介于 min 和 max 范围内的元素数量 详情说明 http://redisdoc.com/sorted_set/zlexcount.html
Long	zLexCount(String key, double min, double max) 获取集合 Key 中，成员介于 min 和 max 范围内的元素数量 详情说明 http://redisdoc.com/sorted_set/zlexcount.html
Long	zLexCount(String key, String min, String max) 获取集合 Key 中，成员介于 min 和 max 范围内的元素数量 详情说明 http://redisdoc.com/sorted_set/zlexcount.html
List<Double>	zMScore(byte[] key, byte[]... members) 返回有序集中指定成员的 members 的 scores 详情说明 https://www.redis.com.cn/commands/zmscore.html
List<Double>	zMScore(String key, String... members) 返回有序集中指定成员的 members 的 scores 详情说明 https://www.redis.com.cn/commands/zmscore.html
Tuple	zPopMax(byte[] key) 删除并返回有序集合 key 中的 1 个具有最高得分的成员。
List<Tuple>	zPopMax(byte[] key, long count) 删除并返回有序集合 key 中的 count 个具有最高得分的成员。
Tuple	zPopMax(String key) 删除并返回有序集合 key 中的 1 个具有最高得分的成员。
List<Tuple>	zPopMax(String key, long count) 删除并返回有序集合 key 中的 count 个具有最高得分的成员。
Tuple	zPopMin(byte[] key) 删除并返回有序集合 key 中的 1 个具有最低得分的成员。
List<Tuple>	zPopMin(byte[] key, long count) 删除并返回有序集合 key 中的 count 个具有最低得分的成员。
Tuple	zPopMin(String key) 删除并返回有序集合 key 中的 1 个具有最低得分的成员。
List<Tuple>	zPopMin(String key, long count) 删除并返回有序集合 key 中的 count 个具有最低得分的成员。
byte[]	zRandMember(byte[] key) 返回有序集合 key 中的一个随机元素 详情说明 https://redis.io/commands/zrandmember/
List<byte[]>	zRandMember(byte[] key, long count) 返回有序集合 key 中的 count 个随机元素 详情说明 https://redis.io/commands/zrandmember/
String	zRandMember(String key) 返回有序集合 key 中的一个随机元素 详情说明 https://redis.io/commands/zrandmember/
List<String>	zRandMember(String key, long count) 返回有序集合 key 中的 count 个随机元素 详情说明 https://redis.io/commands/zrandmember/
List<Tuple>	zRandMemberWithScores(byte[] key, long count) 返回有序集合 key 中的 count 个随机元素及 score 详情说明 https://redis.io/commands/zrandmember/
List<Tuple>	zRandMemberWithScores(String key, long count) 返回有序集合 key 中的 count 个随机元素及 score 详情说明 https://redis.io/commands/zrandmember/
List<byte[]>	zRange(byte[] key, long start, long end) 获取有序集 key 中，指定区间内的成员；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
List<String>	zRange(String key, long start, long end) 获取有序集 key 中，指定区间内的成员；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
List<byte[]>	zRangeByLex(byte[] key, byte[] min, byte[] max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<byte[]>	zRangeByLex(byte[] key, byte[] min, byte[] max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的从 offset 开始的 count 个成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<byte[]>	zRangeByLex(byte[] key, double min, double max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<byte[]>	zRangeByLex(byte[] key, double min, double max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的从 offset 开始的 count 个成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<String>	zRangeByLex(String key, double min, double max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<String>	zRangeByLex(String key, double min, double max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的从 offset 开始的 count 个成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<String>	zRangeByLex(String key, String min, String max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<String>	zRangeByLex(String key, String min, String max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的从 offset 开始的 count 个成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<byte[]>	zRangeByScore(byte[] key, byte[] min, byte[] max) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<byte[]>	zRangeByScore(byte[] key, byte[] min, byte[] max, long offset, long count) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<byte[]>	zRangeByScore(byte[] key, double min, double max) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<byte[]>	zRangeByScore(byte[] key, double min, double max, long offset, long count) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<String>	zRangeByScore(String key, double min, double max) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<String>	zRangeByScore(String key, double min, double max, long offset, long count) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<String>	zRangeByScore(String key, String min, String max) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<String>	zRangeByScore(String key, String min, String max, long offset, long count) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<Tuple>	zRangeByScoreWithScores(byte[] key, byte[] min, byte[] max) 获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<Tuple>	zRangeByScoreWithScores(byte[] key, byte[] min, byte[] max, long offset, long count) 获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<Tuple>	zRangeByScoreWithScores(byte[] key, double min, double max) 获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<Tuple>	zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) 获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<Tuple>	zRangeByScoreWithScores(String key, double min, double max) 获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<Tuple>	zRangeByScoreWithScores(String key, double min, double max, long offset, long count) 获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<Tuple>	zRangeByScoreWithScores(String key, String min, String max) 获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
List<Tuple>	zRangeByScoreWithScores(String key, String min, String max, long offset, long count) 获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
Long	zRangeStore(byte[] destKey, byte[] key, long start, long end) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(byte[] destKey, byte[] key, long start, long end, boolean rev) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(byte[] destKey, byte[] key, long start, long end, boolean rev, long offset, long count) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(byte[] destKey, byte[] key, long start, long end, long offset, long count) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(byte[] destKey, byte[] key, long start, long end, ZRangeBy by) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(byte[] destKey, byte[] key, long start, long end, ZRangeBy by, boolean rev) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(byte[] destKey, byte[] key, long start, long end, ZRangeBy by, boolean rev, long offset, long count) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(byte[] destKey, byte[] key, long start, long end, ZRangeBy by, long offset, long count) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(String destKey, String key, long start, long end) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(String destKey, String key, long start, long end, boolean rev) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(String destKey, String key, long start, long end, boolean rev, long offset, long count) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(String destKey, String key, long start, long end, long offset, long count) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(String destKey, String key, long start, long end, ZRangeBy by) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(String destKey, String key, long start, long end, ZRangeBy by, boolean rev) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(String destKey, String key, long start, long end, ZRangeBy by, boolean rev, long offset, long count) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
Long	zRangeStore(String destKey, String key, long start, long end, ZRangeBy by, long offset, long count) 获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推
List<Tuple>	zRangeWithScores(byte[] key, long start, long end) 获取有序集 key 中，指定区间内的带有 score 成员；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
List<Tuple>	zRangeWithScores(String key, long start, long end) 获取有序集 key 中，指定区间内的带有 score 成员；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
Long	zRank(byte[] key, byte[] member) 获取有序集 key 中成员 member 的排名；其中有序集成员按 score 值递增（从小到大）顺序排列 详情说明 http://redisdoc.com/sorted_set/zrank.html
Long	zRank(String key, String member) 获取有序集 key 中成员 member 的排名；其中有序集成员按 score 值递增（从小到大）顺序排列 详情说明 http://redisdoc.com/sorted_set/zrank.html
Long	zRem(byte[] key, byte[]... members) 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略 详情说明 http://redisdoccom/sorted_set/zrem.html
Long	zRem(String key, String... members) 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略 详情说明 http://redisdoc.com/sorted_set/zrem.html
Long	zRemRangeByLex(byte[] key, byte[] min, byte[] max) 对于一个所有成员的分值都相同的有序集合键 key 来说，这个命令会移除该集合中，成员介于 min 和 max 范围内的所有元素 详情说明 http://redisdoc.com/sorted_set/zremrangebylex.html
Long	zRemRangeByLex(String key, String min, String max) 对于一个所有成员的分值都相同的有序集合键 key 来说，这个命令会移除该集合中，成员介于 min 和 max 范围内的所有元素 详情说明 http://redisdoc.com/sorted_set/zremrangebylex.html
Long	zRemRangeByRank(byte[] key, long start, long end) 移除有序集 key 中，指定排名（rank）区间内的所有成员； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zremrangebyrank.html
Long	zRemRangeByRank(String key, long start, long end) 移除有序集 key 中，指定排名（rank）区间内的所有成员； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zremrangebyrank.html
Long	zRemRangeByScore(byte[] key, byte[] min, byte[] max) 移除有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员 详情说明 http://redisdoc.com/sorted_set/zremrangebyscore.html
Long	zRemRangeByScore(byte[] key, double min, double max) 移除有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员 详情说明 http://redisdoc.com/sorted_set/zremrangebyscore.html
Long	zRemRangeByScore(String key, double min, double max) 移除有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员 详情说明 http://redisdoc.com/sorted_set/zremrangebyscore.html
Long	zRemRangeByScore(String key, String min, String max) 移除有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员 详情说明 http://redisdoc.com/sorted_set/zremrangebyscore.html
List<byte[]>	zRevRange(byte[] key, long start, long end) 获取有序集 key 中，指定区间内的成员；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
List<String>	zRevRange(String key, long start, long end) 获取有序集 key 中，指定区间内的成员；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
List<byte[]>	zRevRangeByLex(byte[] key, byte[] min, byte[] max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<byte[]>	zRevRangeByLex(byte[] key, byte[] min, byte[] max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间从 offset 开始的 count 个成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<String>	zRevRangeByLex(String key, String min, String max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<String>	zRevRangeByLex(String key, String min, String max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间从 offset 开始的 count 个成员 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
List<byte[]>	zRevRangeByScore(byte[] key, byte[] min, byte[] max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<byte[]>	zRevRangeByScore(byte[] key, byte[] min, byte[] max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<byte[]>	zRevRangeByScore(byte[] key, double min, double max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<byte[]>	zRevRangeByScore(byte[] key, double min, double max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<String>	zRevRangeByScore(String key, double min, double max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<String>	zRevRangeByScore(String key, double min, double max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<String>	zRevRangeByScore(String key, String min, String max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<String>	zRevRangeByScore(String key, String min, String max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<Tuple>	zRevRangeByScoreWithScores(byte[] key, byte[] min, byte[] max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的带有 score 的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<Tuple>	zRevRangeByScoreWithScores(byte[] key, byte[] min, byte[] max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个带有 score 的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<Tuple>	zRevRangeByScoreWithScores(byte[] key, double min, double max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的带有 score 的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<Tuple>	zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个带有 score 的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<Tuple>	zRevRangeByScoreWithScores(String key, double min, double max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的带有 score 的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<Tuple>	zRevRangeByScoreWithScores(String key, double min, double max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个带有 score 的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<Tuple>	zRevRangeByScoreWithScores(String key, String min, String max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的带有 score 的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<Tuple>	zRevRangeByScoreWithScores(String key, String min, String max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个带有 score 的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
List<Tuple>	zRevRangeWithScores(byte[] key, long start, long end) 获取有序集 key 中，带有 score 指定区间内的成员；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
List<Tuple>	zRevRangeWithScores(String key, long start, long end) 获取有序集 key 中，带有 score 指定区间内的成员；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
Long	zRevRank(byte[] key, byte[] member) 获取有序集 key 中成员 member 的排名。
Long	zRevRank(String key, String member) 获取有序集 key 中成员 member 的排名。
ScanResult<List<Tuple>>	zScan(byte[] key, byte[] cursor) 迭代有序集 key 中的键值对 详情说明 http://redisdoc.com/sorted_set/zscan.html
ScanResult<List<Tuple>>	zScan(byte[] key, byte[] cursor, byte[] pattern) 迭代有序集 key 中的键值对 详情说明 http://redisdoc.com/sorted_set/zscan.html
ScanResult<List<Tuple>>	zScan(byte[] key, byte[] cursor, byte[] pattern, long count) 迭代有序集 key 中的键值对 详情说明 http://redisdoc.com/sorted_set/zscan.html
ScanResult<List<Tuple>>	zScan(byte[] key, byte[] cursor, long count) 迭代有序集 key 中的键值对 详情说明 http://redisdoc.com/sorted_set/zscan.html
ScanResult<List<Tuple>>	zScan(String key, String cursor) 迭代有序集 key 中的键值对 详情说明 http://redisdoc.com/sorted_set/zscan.html
ScanResult<List<Tuple>>	zScan(String key, String cursor, long count) 迭代有序集 key 中的键值对 详情说明 http://redisdoc.com/sorted_set/zscan.html
ScanResult<List<Tuple>>	zScan(String key, String cursor, String pattern) 迭代有序集 key 中的键值对 详情说明 http://redisdoc.com/sorted_set/zscan.html
ScanResult<List<Tuple>>	zScan(String key, String cursor, String pattern, long count) 迭代有序集 key 中的键值对 详情说明 http://redisdoc.com/sorted_set/zscan.html
Double	zScore(byte[] key, byte[] member) 获取有序集 key 中，成员 member 的 score 值 详情说明 http://redisdoc.com/sorted_set/zscore.html
Double	zScore(String key, String member) 获取有序集 key 中，成员 member 的 score 值 详情说明 http://redisdoc.com/sorted_set/zscore.html
Set<byte[]>	zUnion(byte[]... keys) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<byte[]>	zUnion(byte[][] keys, Aggregate aggregate) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<byte[]>	zUnion(byte[][] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<byte[]>	zUnion(byte[][] keys, double... weights) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<String>	zUnion(String... keys) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<String>	zUnion(String[] keys, Aggregate aggregate) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<String>	zUnion(String[] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<String>	zUnion(String[] keys, double... weights) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Long	zUnionStore(byte[] destKey, byte[]... keys) 计算给定的一个或多个有序集的并集，并将该并集储存到 destKey 详情说明 http://redisdoc.com/sorted_set/zunionstore.html
Long	zUnionStore(byte[] destKey, byte[][] keys, Aggregate aggregate) 计算给定的一个或多个有序集的并集，并将该并集储存到 destKey 详情说明 http://redisdoc.com/sorted_set/zunionstore.html
Long	zUnionStore(byte[] destKey, byte[][] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集的并集，并将该并集储存到 destKey 详情说明 http://redisdoc.com/sorted_set/zunionstore.html
Long	zUnionStore(byte[] destKey, byte[][] keys, double... weights) 计算给定的一个或多个有序集的并集，并将该并集储存到 destKey 详情说明 http://redisdoc.com/sorted_set/zunionstore.html
Long	zUnionStore(String destKey, String... keys) 计算给定的一个或多个有序集的并集，并将该并集储存到 destKey 详情说明 http://redisdoc.com/sorted_set/zunionstore.html
Long	zUnionStore(String destKey, String[] keys, Aggregate aggregate) 计算给定的一个或多个有序集的并集，并将该并集储存到 destKey 详情说明 http://redisdoc.com/sorted_set/zunionstore.html
Long	zUnionStore(String destKey, String[] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集的并集，并将该并集储存到 destKey 详情说明 http://redisdoc.com/sorted_set/zunionstore.html
Long	zUnionStore(String destKey, String[] keys, double... weights) 计算给定的一个或多个有序集的并集，并将该并集储存到 destKey 详情说明 http://redisdoc.com/sorted_set/zunionstore.html
Set<Tuple>	zUnionWithScores(byte[]... keys) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<Tuple>	zUnionWithScores(byte[][] keys, Aggregate aggregate) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<Tuple>	zUnionWithScores(byte[][] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<Tuple>	zUnionWithScores(byte[][] keys, double... weights) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<Tuple>	zUnionWithScores(String... keys) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<Tuple>	zUnionWithScores(String[] keys, Aggregate aggregate) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<Tuple>	zUnionWithScores(String[] keys, Aggregate aggregate, double... weights) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html
Set<Tuple>	zUnionWithScores(String[] keys, double... weights) 计算给定的一个或多个有序集的并集 详情说明 https://www.redis.com.cn/commands/zunion.html

从类继承的方法 com.buession.redis.client.jedis.operations.AbstractSortedSetOperations

zRemRangeByLex, zRemRangeByLex, zRevRangeByLex, zRevRangeByLex, zRevRangeByLex, zRevRangeByLex, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan

从类继承的方法 java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

构造器详细资料

JedisSortedSetOperations

public JedisSortedSetOperations(JedisStandaloneClient client)

方法详细资料

zPopMin

public Tuple zPopMin(String key)

从接口复制的说明: SortedSetCommands

删除并返回有序集合 key 中的 1 个具有最低得分的成员。

详情说明 https://www.redis.com.cn/commands/zpopmin.html

参数:

key - 弹出的元素和分数列表

返回:

弹出的元素和分数列表

zPopMin

public Tuple zPopMin(byte[] key)

从接口复制的说明: SortedSetCommands

删除并返回有序集合 key 中的 1 个具有最低得分的成员。

详情说明 https://www.redis.com.cn/commands/zpopmin.html

参数:

key - 弹出的元素和分数列表

返回:

弹出的元素和分数列表

zPopMin

public List<Tuple> zPopMin(String key,
                           long count)

从接口复制的说明: SortedSetCommands

删除并返回有序集合 key 中的 count 个具有最低得分的成员。

详情说明 https://www.redis.com.cn/commands/zpopmin.html

参数:

key - 弹出的元素和分数列表

count - 删除个数

返回:

弹出的元素和分数列表

zPopMin

public List<Tuple> zPopMin(byte[] key,
                           long count)

从接口复制的说明: SortedSetCommands

删除并返回有序集合 key 中的 count 个具有最低得分的成员。

详情说明 https://www.redis.com.cn/commands/zpopmin.html

参数:

key - 弹出的元素和分数列表

count - 删除个数

返回:

弹出的元素和分数列表

zPopMax

public Tuple zPopMax(String key)

从接口复制的说明: SortedSetCommands

删除并返回有序集合 key 中的 1 个具有最高得分的成员。

参数:

key - 弹出的元素和分数列表

返回:

弹出的元素和分数列表

zPopMax

public Tuple zPopMax(byte[] key)

从接口复制的说明: SortedSetCommands

删除并返回有序集合 key 中的 1 个具有最高得分的成员。

参数:

key - 弹出的元素和分数列表

返回:

弹出的元素和分数列表

zPopMax

public List<Tuple> zPopMax(String key,
                           long count)

从接口复制的说明: SortedSetCommands

删除并返回有序集合 key 中的 count 个具有最高得分的成员。

参数:

key - 弹出的元素和分数列表

count - 删除个数

返回:

弹出的元素和分数列表

zPopMax

public List<Tuple> zPopMax(byte[] key,
                           long count)

从接口复制的说明: SortedSetCommands

删除并返回有序集合 key 中的 count 个具有最高得分的成员。

参数:

key - 弹出的元素和分数列表

count - 删除个数

返回:

弹出的元素和分数列表

bzPopMin

public KeyedZSetElement bzPopMin(String[] keys,
                                 int timeout)

从接口复制的说明: SortedSetCommands

从非空的第一个有序集中弹出得分最小的成员，按照命令中 key 出现的顺序检查；是有序集 ZPOPMIN 的阻塞变体； 当没有成员可以从任何给定的有序集中弹出时，它会阻塞连接

详情说明 https://www.redis.com.cn/commands/bzpopmin.html

参数:

keys - 一个或多个 Key

timeout - 阻塞的最长时间；为 0 时，则无限期地阻塞，单位：秒

返回:

元素 key 名称，成员名称，元素分数

bzPopMin

public KeyedZSetElement bzPopMin(byte[][] keys,
                                 int timeout)

从接口复制的说明: SortedSetCommands

从非空的第一个有序集中弹出得分最小的成员，按照命令中 key 出现的顺序检查；是有序集 ZPOPMIN 的阻塞变体； 当没有成员可以从任何给定的有序集中弹出时，它会阻塞连接

详情说明 https://www.redis.com.cn/commands/bzpopmin.html

参数:

keys - 一个或多个 Key

timeout - 阻塞的最长时间；为 0 时，则无限期地阻塞，单位：秒

返回:

元素 key 名称，成员名称，元素分数

bzPopMax

public KeyedZSetElement bzPopMax(String[] keys,
                                 int timeout)

从接口复制的说明: SortedSetCommands

从非空的第一个有序集中弹出得分最高的成员，按照命令中 key 出现的顺序检查；是有序集 ZPOPMAX 的阻塞变体； 当没有成员可以从任何给定的有序集中弹出时，它会阻塞连接

详情说明 https://www.redis.com.cn/commands/bzpopmax.html

参数:

keys - 一个或多个 Key

timeout - 阻塞的最长时间；为 0 时，则无限期地阻塞，单位：秒

返回:

元素 key 名称，成员名称，元素分数

bzPopMax

public KeyedZSetElement bzPopMax(byte[][] keys,
                                 int timeout)

从接口复制的说明: SortedSetCommands

从非空的第一个有序集中弹出得分最高的成员，按照命令中 key 出现的顺序检查；是有序集 ZPOPMAX 的阻塞变体； 当没有成员可以从任何给定的有序集中弹出时，它会阻塞连接

详情说明 https://www.redis.com.cn/commands/bzpopmax.html

参数:

keys - 一个或多个 Key

timeout - 阻塞的最长时间；为 0 时，则无限期地阻塞，单位：秒

返回:

元素 key 名称，成员名称，元素分数

zAdd

public Long zAdd(String key,
                 Map<String,Double> members)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 https://www.redis.com.cn/commands/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(byte[] key,
                 Map<byte[],Double> members)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 https://www.redis.com.cn/commands/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(String key,
                 Map<String,Double> members,
                 NxXx nxXx)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 https://www.redis.com.cn/commands/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

nxXx - 更新成员方式： 1）NxXx.NX：不更新存在的成员，只添加新成员 2）NxXx.XX：仅更新存在的成员，不添加新成员

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(byte[] key,
                 Map<byte[],Double> members,
                 NxXx nxXx)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 http://redisdoc.com/sorted_set/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

nxXx - 更新成员方式： 1）NxXx.NX：不更新存在的成员，只添加新成员 2）NxXx.XX：仅更新存在的成员，不添加新成员

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(String key,
                 Map<String,Double> members,
                 GtLt gtLt)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 https://www.redis.com.cn/commands/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

gtLt - 更新新的分值方式： 1）GtLt.LT: 更新新的分值比当前分值小的成员，不存在则新增 2）GtLt.GT: 更新新的分值比当前分值大的成员，不存在则新增

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(byte[] key,
                 Map<byte[],Double> members,
                 GtLt gtLt)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 http://redisdoc.com/sorted_set/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

gtLt - 更新新的分值方式： 1）GtLt.LT: 更新新的分值比当前分值小的成员，不存在则新增 2）GtLt.GT: 更新新的分值比当前分值大的成员，不存在则新增

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(String key,
                 Map<String,Double> members,
                 boolean ch)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 https://www.redis.com.cn/commands/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

ch - 是否返回变更成员的数量；变更的成员是指新增成员 和 score值更新的成员，命令指明的和之前 score 值相同的成员不计在内； 在通常情况下，ZADD返回值只计算新添加成员的数量

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(byte[] key,
                 Map<byte[],Double> members,
                 boolean ch)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 http://redisdoc.com/sorted_set/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

ch - 是否返回变更成员的数量；变更的成员是指新增成员 和 score值更新的成员，命令指明的和之前 score 值相同的成员不计在内； 在通常情况下，ZADD返回值只计算新添加成员的数量

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(String key,
                 Map<String,Double> members,
                 NxXx nxXx,
                 GtLt gtLt)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 https://www.redis.com.cn/commands/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

nxXx - 更新成员方式： 1）NxXx.NX：不更新存在的成员，只添加新成员 2）NxXx.XX：仅更新存在的成员，不添加新成员

gtLt - 更新新的分值方式： 1）GtLt.LT: 更新新的分值比当前分值小的成员，不存在则新增 2）GtLt.GT: 更新新的分值比当前分值大的成员，不存在则新增

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(byte[] key,
                 Map<byte[],Double> members,
                 NxXx nxXx,
                 GtLt gtLt)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 http://redisdoc.com/sorted_set/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

nxXx - 更新成员方式： 1）NxXx.NX：不更新存在的成员，只添加新成员 2）NxXx.XX：仅更新存在的成员，不添加新成员

gtLt - 更新新的分值方式： 1）GtLt.LT: 更新新的分值比当前分值小的成员，不存在则新增 2）GtLt.GT: 更新新的分值比当前分值大的成员，不存在则新增

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(String key,
                 Map<String,Double> members,
                 NxXx nxXx,
                 boolean ch)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 https://www.redis.com.cn/commands/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

nxXx - 更新成员方式： 1）NxXx.NX：不更新存在的成员，只添加新成员 2）NxXx.XX：仅更新存在的成员，不添加新成员

ch - 是否返回变更成员的数量；变更的成员是指新增成员 和 score值更新的成员，命令指明的和之前 score 值相同的成员不计在内； 在通常情况下，ZADD返回值只计算新添加成员的数量

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(byte[] key,
                 Map<byte[],Double> members,
                 NxXx nxXx,
                 boolean ch)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 http://redisdoc.com/sorted_set/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

nxXx - 更新成员方式： 1）NxXx.NX：不更新存在的成员，只添加新成员 2）NxXx.XX：仅更新存在的成员，不添加新成员

ch - 是否返回变更成员的数量；变更的成员是指新增成员 和 score值更新的成员，命令指明的和之前 score 值相同的成员不计在内； 在通常情况下，ZADD返回值只计算新添加成员的数量

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(String key,
                 Map<String,Double> members,
                 GtLt gtLt,
                 boolean ch)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 https://www.redis.com.cn/commands/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

gtLt - 更新新的分值方式： 1）GtLt.LT: 更新新的分值比当前分值小的成员，不存在则新增 2）GtLt.GT: 更新新的分值比当前分值大的成员，不存在则新增

ch - 是否返回变更成员的数量；变更的成员是指新增成员 和 score值更新的成员，命令指明的和之前 score 值相同的成员不计在内； 在通常情况下，ZADD返回值只计算新添加成员的数量

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(byte[] key,
                 Map<byte[],Double> members,
                 GtLt gtLt,
                 boolean ch)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 http://redisdoc.com/sorted_set/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

gtLt - 更新新的分值方式： 1）GtLt.LT: 更新新的分值比当前分值小的成员，不存在则新增 2）GtLt.GT: 更新新的分值比当前分值大的成员，不存在则新增

ch - 是否返回变更成员的数量；变更的成员是指新增成员 和 score值更新的成员，命令指明的和之前 score 值相同的成员不计在内； 在通常情况下，ZADD返回值只计算新添加成员的数量

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(String key,
                 Map<String,Double> members,
                 NxXx nxXx,
                 GtLt gtLt,
                 boolean ch)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 https://www.redis.com.cn/commands/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

nxXx - 更新成员方式： 1）NxXx.NX：不更新存在的成员，只添加新成员 2）NxXx.XX：仅更新存在的成员，不添加新成员

gtLt - 更新新的分值方式： 1）GtLt.LT: 更新新的分值比当前分值小的成员，不存在则新增 2）GtLt.GT: 更新新的分值比当前分值大的成员，不存在则新增

ch - 是否返回变更成员的数量；变更的成员是指新增成员 和 score值更新的成员，命令指明的和之前 score 值相同的成员不计在内； 在通常情况下，ZADD返回值只计算新添加成员的数量

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zAdd

public Long zAdd(byte[] key,
                 Map<byte[],Double> members,
                 NxXx nxXx,
                 GtLt gtLt,
                 boolean ch)

从接口复制的说明: SortedSetCommands

将一个或多个 member 元素及其 score 值加入到有序集 key 当中

详情说明 http://redisdoc.com/sorted_set/zadd.html

参数:

key - Key

members - 一个或多个 member 元素及其 score

nxXx - 更新成员方式： 1）NxXx.NX：不更新存在的成员，只添加新成员 2）NxXx.XX：仅更新存在的成员，不添加新成员

gtLt - 更新新的分值方式： 1）GtLt.LT: 更新新的分值比当前分值小的成员，不存在则新增 2）GtLt.GT: 更新新的分值比当前分值大的成员，不存在则新增

ch - 是否返回变更成员的数量；变更的成员是指新增成员 和 score值更新的成员，命令指明的和之前 score 值相同的成员不计在内； 在通常情况下，ZADD返回值只计算新添加成员的数量

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员

zCard

public Long zCard(String key)

从接口复制的说明: SortedSetCommands

获取有序集 key 的基数

详情说明 http://redisdoc.com/sorted_set/zcard.html

参数:

key - Key

返回:

有序集 key 的基数

zCard

public Long zCard(byte[] key)

从接口复制的说明: SortedSetCommands

获取有序集 key 的基数

详情说明 http://redisdoc.com/sorted_set/zcard.html

参数:

key - Key

返回:

有序集 key 的基数

zCount

public Long zCount(String key,
                   double min,
                   double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值在 min 和 max 之间（包括 score 值等于 min 或 max ）的成员的数量

详情说明 http://redisdoc.com/sorted_set/zcount.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

score 值在 min 和 max 之间的成员的数量

zCount

public Long zCount(byte[] key,
                   double min,
                   double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值在 min 和 max 之间（包括 score 值等于 min 或 max ）的成员的数量

详情说明 http://redisdoc.com/sorted_set/zcount.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

score 值在 min 和 max 之间的成员的数量

zCount

public Long zCount(String key,
                   String min,
                   String max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值在 min 和 max 之间（包括 score 值等于 min 或 max ）的成员的数量

详情说明 http://redisdoc.com/sorted_set/zcount.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

score 值在 min 和 max 之间的成员的数量

zCount

public Long zCount(byte[] key,
                   byte[] min,
                   byte[] max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值在 min 和 max 之间（包括 score 值等于 min 或 max ）的成员的数量

详情说明 http://redisdoc.com/sorted_set/zcount.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

score 值在 min 和 max 之间的成员的数量

zDiff

public Set<String> zDiff(String... keys)

从接口复制的说明: SortedSetCommands

This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client

详情说明 https://redis.io/commands/zdiff/

参数:

keys - 一个或多个 Key

返回:

The result of the difference

zDiff

public Set<byte[]> zDiff(byte[]... keys)

从接口复制的说明: SortedSetCommands

This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client

详情说明 https://redis.io/commands/zdiff/

参数:

keys - 一个或多个 Key

返回:

The result of the difference

zDiffWithScores

public Set<Tuple> zDiffWithScores(String... keys)

从接口复制的说明: SortedSetCommands

This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client

详情说明 https://redis.io/commands/zdiff/

参数:

keys - 一个或多个 Key

返回:

The result of the difference with their scores

zDiffWithScores

public Set<Tuple> zDiffWithScores(byte[]... keys)

从接口复制的说明: SortedSetCommands

This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client

详情说明 https://redis.io/commands/zdiff/

参数:

keys - 一个或多个 Key

返回:

The result of the difference with their scores

zDiffStore

public Long zDiffStore(String destKey,
                       String... keys)

从接口复制的说明: SortedSetCommands

Computes the difference between the first and all successive input sorted sets and stores the result in destination

详情说明 https://redis.io/commands/zdiffstore/

参数:

destKey - 目标 Key

keys - 一个或多个 Key

返回:

结果集中的元素数量

zDiffStore

public Long zDiffStore(byte[] destKey,
                       byte[]... keys)

从接口复制的说明: SortedSetCommands

Computes the difference between the first and all successive input sorted sets and stores the result in destination

详情说明 https://redis.io/commands/zdiffstore/

参数:

destKey - 目标 Key

keys - 一个或多个 Key

返回:

结果集中的元素数量

zIncrBy

public Double zIncrBy(String key,
                      double increment,
                      String member)

从接口复制的说明: SortedSetCommands

为有序集 key 的成员 member 的 score 值加上增量 increment

详情说明 http://redisdoc.com/sorted_set/zincrby.html

参数:

key - Key

increment - 增量

member - member 元素

返回:

member 成员的新 score 值

zIncrBy

public Double zIncrBy(byte[] key,
                      double increment,
                      byte[] member)

从接口复制的说明: SortedSetCommands

为有序集 key 的成员 member 的 score 值加上增量 increment

详情说明 http://redisdoc.com/sorted_set/zincrby.html

参数:

key - Key

increment - 增量

member - member 元素

返回:

member 成员的新 score 值

zInter

public Set<String> zInter(String... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

返回:

有序集合的交集

zInter

public Set<byte[]> zInter(byte[]... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

返回:

有序集合的交集

zInter

public Set<String> zInter(String[] keys,
                          Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

aggregate - Aggregate

返回:

有序集合的交集

zInter

public Set<byte[]> zInter(byte[][] keys,
                          Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

aggregate - Aggregate

返回:

有序集合的交集

zInter

public Set<String> zInter(String[] keys,
                          double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

有序集合的交集

zInter

public Set<byte[]> zInter(byte[][] keys,
                          double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

有序集合的交集

zInter

public Set<String> zInter(String[] keys,
                          Aggregate aggregate,
                          double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

aggregate - Aggregate

weights - 每个给定有序集的乘法因子

返回:

有序集合的交集

zInter

public Set<byte[]> zInter(byte[][] keys,
                          Aggregate aggregate,
                          double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

aggregate - Aggregate

weights - 每个给定有序集的乘法因子

返回:

有序集合的交集

zInterWithScores

public Set<Tuple> zInterWithScores(String... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

返回:

含 scores 的有序集合的交集

zInterWithScores

public Set<Tuple> zInterWithScores(byte[]... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

返回:

含 scores 的有序集合的交集

zInterWithScores

public Set<Tuple> zInterWithScores(String[] keys,
                                   Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

aggregate - Aggregate

返回:

含 scores 的有序集合的交集

zInterWithScores

public Set<Tuple> zInterWithScores(byte[][] keys,
                                   Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

aggregate - Aggregate

返回:

含 scores 的有序集合的交集

zInterWithScores

public Set<Tuple> zInterWithScores(String[] keys,
                                   double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

含 scores 的有序集合的交集

zInterWithScores

public Set<Tuple> zInterWithScores(byte[][] keys,
                                   double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

含 scores 的有序集合的交集

zInterWithScores

public Set<Tuple> zInterWithScores(String[] keys,
                                   Aggregate aggregate,
                                   double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

aggregate - Aggregate

weights - 每个给定有序集的乘法因子

返回:

含 scores 的有序集合的交集

zInterWithScores

public Set<Tuple> zInterWithScores(byte[][] keys,
                                   Aggregate aggregate,
                                   double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集合的交集

详情说明 https://redis.io/commands/zinter/

参数:

keys - 一个或多个 Key

aggregate - Aggregate

weights - 每个给定有序集的乘法因子

返回:

含 scores 的有序集合的交集

zInterStore

public Long zInterStore(String destKey,
                        String... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中

详情说明 http://redisdoc.com/sorted_set/zinterstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

返回:

保存到 destKey 结果集的基数

zInterStore

public Long zInterStore(byte[] destKey,
                        byte[]... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中

详情说明 http://redisdoc.com/sorted_set/zinterstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

返回:

保存到 destKey 结果集的基数

zInterStore

public Long zInterStore(String destKey,
                        String[] keys,
                        Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中

详情说明 http://redisdoc.com/sorted_set/zinterstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

返回:

保存到 destKey 结果集的基数

zInterStore

public Long zInterStore(byte[] destKey,
                        byte[][] keys,
                        Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中

详情说明 http://redisdoc.com/sorted_set/zinterstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

返回:

保存到 destKey 结果集的基数

zInterStore

public Long zInterStore(String destKey,
                        String[] keys,
                        double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中

详情说明 http://redisdoc.com/sorted_set/zinterstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

保存到 destKey 结果集的基数

zInterStore

public Long zInterStore(byte[] destKey,
                        byte[][] keys,
                        double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中

详情说明 http://redisdoc.com/sorted_set/zinterstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

保存到 destKey 结果集的基数

zInterStore

public Long zInterStore(String destKey,
                        String[] keys,
                        Aggregate aggregate,
                        double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中

详情说明 http://redisdoc.com/sorted_set/zinterstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

weights - 每个给定有序集的乘法因子

返回:

保存到 destKey 结果集的基数

zInterStore

public Long zInterStore(byte[] destKey,
                        byte[][] keys,
                        Aggregate aggregate,
                        double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的交集，并将该交集储存到 destKey 中

详情说明 http://redisdoc.com/sorted_set/zinterstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

weights - 每个给定有序集的乘法因子

返回:

保存到 destKey 结果集的基数

zLexCount

public Long zLexCount(String key,
                      double min,
                      double max)

从接口复制的说明: SortedSetCommands

获取集合 Key 中，成员介于 min 和 max 范围内的元素数量

详情说明 http://redisdoc.com/sorted_set/zlexcount.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

集合 Key 中，成员介于 min 和 max 范围内的元素数量

zLexCount

public Long zLexCount(byte[] key,
                      double min,
                      double max)

从接口复制的说明: SortedSetCommands

获取集合 Key 中，成员介于 min 和 max 范围内的元素数量

详情说明 http://redisdoc.com/sorted_set/zlexcount.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

集合 Key 中，成员介于 min 和 max 范围内的元素数量

zLexCount

public Long zLexCount(String key,
                      String min,
                      String max)

从接口复制的说明: SortedSetCommands

获取集合 Key 中，成员介于 min 和 max 范围内的元素数量

详情说明 http://redisdoc.com/sorted_set/zlexcount.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

集合 Key 中，成员介于 min 和 max 范围内的元素数量

zLexCount

public Long zLexCount(byte[] key,
                      byte[] min,
                      byte[] max)

从接口复制的说明: SortedSetCommands

获取集合 Key 中，成员介于 min 和 max 范围内的元素数量

详情说明 http://redisdoc.com/sorted_set/zlexcount.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

集合 Key 中，成员介于 min 和 max 范围内的元素数量

zMScore

public List<Double> zMScore(String key,
                            String... members)

从接口复制的说明: SortedSetCommands

返回有序集中指定成员的 members 的 scores

详情说明 https://www.redis.com.cn/commands/zmscore.html

参数:

key - Key

members - 成员

返回:

有序集中指定成员的 members 的 scores

zMScore

public List<Double> zMScore(byte[] key,
                            byte[]... members)

从接口复制的说明: SortedSetCommands

返回有序集中指定成员的 members 的 scores

详情说明 https://www.redis.com.cn/commands/zmscore.html

参数:

key - Key

members - 成员

返回:

有序集中指定成员的 members 的 scores

zRandMember

public String zRandMember(String key)

从接口复制的说明: SortedSetCommands

返回有序集合 key 中的一个随机元素

详情说明 https://redis.io/commands/zrandmember/

参数:

key - Key

返回:

有序集合 key 中的一个随机元素

zRandMember

public byte[] zRandMember(byte[] key)

从接口复制的说明: SortedSetCommands

返回有序集合 key 中的一个随机元素

详情说明 https://redis.io/commands/zrandmember/

参数:

key - Key

返回:

有序集合 key 中的一个随机元素

zRandMember

public List<String> zRandMember(String key,
                                long count)

从接口复制的说明: SortedSetCommands

返回有序集合 key 中的 count 个随机元素

详情说明 https://redis.io/commands/zrandmember/

参数:

key - Key

count - 需要返回的元素数量

返回:

有序集合 key 中的随机元素

zRandMember

public List<byte[]> zRandMember(byte[] key,
                                long count)

从接口复制的说明: SortedSetCommands

返回有序集合 key 中的 count 个随机元素

详情说明 https://redis.io/commands/zrandmember/

参数:

key - Key

count - 需要返回的元素数量

返回:

有序集合 key 中的随机元素

zRandMemberWithScores

public List<Tuple> zRandMemberWithScores(String key,
                                         long count)

从接口复制的说明: SortedSetCommands

返回有序集合 key 中的 count 个随机元素及 score

详情说明 https://redis.io/commands/zrandmember/

参数:

key - Key

count - 需要返回的元素数量

返回:

有序集合 key 中的随机元素

zRandMemberWithScores

public List<Tuple> zRandMemberWithScores(byte[] key,
                                         long count)

从接口复制的说明: SortedSetCommands

返回有序集合 key 中的 count 个随机元素及 score

详情说明 https://redis.io/commands/zrandmember/

参数:

key - Key

count - 需要返回的元素数量

返回:

有序集合 key 中的随机元素

zRange

public List<String> zRange(String key,
                           long start,
                           long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zrange.html

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

指定区间内，有序集成员的列表； 当 start 的值比有序集的最大下标还要大，或是 start > end 时，返回一个空列表； 当 end 参数的值比有序集的最大下标还要大时，最多返回到 end

zRange

public List<byte[]> zRange(byte[] key,
                           long start,
                           long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zrange.html

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

指定区间内，有序集成员的列表； 当 start 的值比有序集的最大下标还要大，或是 start > end 时，返回一个空列表； 当 end 参数的值比有序集的最大下标还要大时，最多返回到 end

zRangeWithScores

public List<Tuple> zRangeWithScores(String key,
                                    long start,
                                    long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的带有 score 成员；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zrange.html

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

指定区间内，带有 score 有序集成员的列表； 当 start 的值比有序集的最大下标还要大，或是 start > end 时，返回一个空列表； 当 end 参数的值比有序集的最大下标还要大时，最多返回到 end

zRangeWithScores

public List<Tuple> zRangeWithScores(byte[] key,
                                    long start,
                                    long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的带有 score 成员；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zrange.html

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

指定区间内，带有 score 有序集成员的列表； 当 start 的值比有序集的最大下标还要大，或是 start > end 时，返回一个空列表； 当 end 参数的值比有序集的最大下标还要大时，最多返回到 end

zRangeByLex

public List<String> zRangeByLex(String key,
                                double min,
                                double max)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员的列表

zRangeByLex

public List<byte[]> zRangeByLex(byte[] key,
                                double min,
                                double max)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员的列表

zRangeByLex

public List<String> zRangeByLex(String key,
                                String min,
                                String max)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员的列表

zRangeByLex

public List<byte[]> zRangeByLex(byte[] key,
                                byte[] min,
                                byte[] max)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员的列表

zRangeByLex

public List<String> zRangeByLex(String key,
                                double min,
                                double max,
                                long offset,
                                long count)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的从 offset 开始的 count 个成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内从 offset 开始的 count 个成员的列表

zRangeByLex

public List<byte[]> zRangeByLex(byte[] key,
                                double min,
                                double max,
                                long offset,
                                long count)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的从 offset 开始的 count 个成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内从 offset 开始的 count 个成员的列表

zRangeByLex

public List<String> zRangeByLex(String key,
                                String min,
                                String max,
                                long offset,
                                long count)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的从 offset 开始的 count 个成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内从 offset 开始的 count 个成员的列表

zRangeByLex

public List<byte[]> zRangeByLex(byte[] key,
                                byte[] min,
                                byte[] max,
                                long offset,
                                long count)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的从 offset 开始的 count 个成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内从 offset 开始的 count 个成员的列表

zRangeByScore

public List<String> zRangeByScore(String key,
                                  double min,
                                  double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRangeByScore

public List<byte[]> zRangeByScore(byte[] key,
                                  double min,
                                  double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRangeByScore

public List<String> zRangeByScore(String key,
                                  String min,
                                  String max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRangeByScore

public List<byte[]> zRangeByScore(byte[] key,
                                  byte[] min,
                                  byte[] max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRangeByScore

public List<String> zRangeByScore(String key,
                                  double min,
                                  double max,
                                  long offset,
                                  long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内从 offset 开是的 count 个，有序集成员的列表

zRangeByScore

public List<byte[]> zRangeByScore(byte[] key,
                                  double min,
                                  double max,
                                  long offset,
                                  long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内从 offset 开是的 count 个，有序集成员的列表

zRangeByScore

public List<String> zRangeByScore(String key,
                                  String min,
                                  String max,
                                  long offset,
                                  long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内从 offset 开是的 count 个，有序集成员的列表

zRangeByScore

public List<byte[]> zRangeByScore(byte[] key,
                                  byte[] min,
                                  byte[] max,
                                  long offset,
                                  long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内从 offset 开是的 count 个，有序集成员的列表

zRangeByScoreWithScores

public List<Tuple> zRangeByScoreWithScores(String key,
                                           double min,
                                           double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，带有 score 的有序集成员的列表

zRangeByScoreWithScores

public List<Tuple> zRangeByScoreWithScores(byte[] key,
                                           double min,
                                           double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，带有 score 的有序集成员的列表

zRangeByScoreWithScores

public List<Tuple> zRangeByScoreWithScores(String key,
                                           String min,
                                           String max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，带有 score 的有序集成员的列表

zRangeByScoreWithScores

public List<Tuple> zRangeByScoreWithScores(byte[] key,
                                           byte[] min,
                                           byte[] max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，带有 score 的有序集成员的列表

zRangeByScoreWithScores

public List<Tuple> zRangeByScoreWithScores(String key,
                                           double min,
                                           double max,
                                           long offset,
                                           long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内带有 score 的从 offset 开是的 count 个，有序集成员的列表

zRangeByScoreWithScores

public List<Tuple> zRangeByScoreWithScores(byte[] key,
                                           double min,
                                           double max,
                                           long offset,
                                           long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内带有 score 的从 offset 开是的 count 个，有序集成员的列表

zRangeByScoreWithScores

public List<Tuple> zRangeByScoreWithScores(String key,
                                           String min,
                                           String max,
                                           long offset,
                                           long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内带有 score 的从 offset 开是的 count 个，有序集成员的列表

zRangeByScoreWithScores

public List<Tuple> zRangeByScoreWithScores(byte[] key,
                                           byte[] min,
                                           byte[] max,
                                           long offset,
                                           long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 的所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列

详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内带有 score 的从 offset 开是的 count 个，有序集成员的列表

zRangeStore

public Long zRangeStore(String destKey,
                        String key,
                        long start,
                        long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(byte[] destKey,
                        byte[] key,
                        long start,
                        long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(String destKey,
                        String key,
                        long start,
                        long end,
                        ZRangeBy by)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

by - ZRangeBy

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(byte[] destKey,
                        byte[] key,
                        long start,
                        long end,
                        ZRangeBy by)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

by - ZRangeBy

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(String destKey,
                        String key,
                        long start,
                        long end,
                        boolean rev)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

rev - The REV options reverses the order of the 'start' and 'end' elements

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(byte[] destKey,
                        byte[] key,
                        long start,
                        long end,
                        boolean rev)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

rev - The REV options reverses the order of the 'start' and 'end' elements

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(String destKey,
                        String key,
                        long start,
                        long end,
                        long offset,
                        long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

offset - 偏移量

count - 返回个数

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(byte[] destKey,
                        byte[] key,
                        long start,
                        long end,
                        long offset,
                        long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

offset - 偏移量

count - 返回个数

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(String destKey,
                        String key,
                        long start,
                        long end,
                        ZRangeBy by,
                        boolean rev)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

by - ZRangeBy

rev - The REV options reverses the order of the 'start' and 'end' elements

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(byte[] destKey,
                        byte[] key,
                        long start,
                        long end,
                        ZRangeBy by,
                        boolean rev)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

by - ZRangeBy

rev - The REV options reverses the order of the 'start' and 'end' elements

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(String destKey,
                        String key,
                        long start,
                        long end,
                        ZRangeBy by,
                        long offset,
                        long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

by - ZRangeBy

offset - 偏移量

count - 返回个数

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(byte[] destKey,
                        byte[] key,
                        long start,
                        long end,
                        ZRangeBy by,
                        long offset,
                        long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

by - ZRangeBy

offset - 偏移量

count - 返回个数

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(String destKey,
                        String key,
                        long start,
                        long end,
                        boolean rev,
                        long offset,
                        long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

rev - The REV options reverses the order of the 'start' and 'end' elements

offset - 偏移量

count - 返回个数

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(byte[] destKey,
                        byte[] key,
                        long start,
                        long end,
                        boolean rev,
                        long offset,
                        long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

rev - The REV options reverses the order of the 'start' and 'end' elements

offset - 偏移量

count - 返回个数

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(String destKey,
                        String key,
                        long start,
                        long end,
                        ZRangeBy by,
                        boolean rev,
                        long offset,
                        long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

by - ZRangeBy

rev - The REV options reverses the order of the 'start' and 'end' elements

offset - 偏移量

count - 返回个数

返回:

The number of elements in the resulting sorted set

zRangeStore

public Long zRangeStore(byte[] destKey,
                        byte[] key,
                        long start,
                        long end,
                        ZRangeBy by,
                        boolean rev,
                        long offset,
                        long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员，并保存到 destKey 中；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

参数:

destKey - 目标 Key

key - Key

start - 开始位置

end - 结束位置

by - ZRangeBy

rev - The REV options reverses the order of the 'start' and 'end' elements

offset - 偏移量

count - 返回个数

返回:

The number of elements in the resulting sorted set

zRank

public Long zRank(String key,
                  String member)

从接口复制的说明: SortedSetCommands

获取有序集 key 中成员 member 的排名；其中有序集成员按 score 值递增（从小到大）顺序排列

详情说明 http://redisdoc.com/sorted_set/zrank.html

参数:

key - Key

member - member

返回:

如果 member 是有序集 key 的成员，返回 member 的排名； 如果 member 不是有序集 key 的成员，返回 null

zRank

public Long zRank(byte[] key,
                  byte[] member)

从接口复制的说明: SortedSetCommands

获取有序集 key 中成员 member 的排名；其中有序集成员按 score 值递增（从小到大）顺序排列

详情说明 http://redisdoc.com/sorted_set/zrank.html

参数:

key - Key

member - member

返回:

如果 member 是有序集 key 的成员，返回 member 的排名； 如果 member 不是有序集 key 的成员，返回 null

zRem

public Long zRem(String key,
                 String... members)

从接口复制的说明: SortedSetCommands

移除有序集 key 中的一个或多个成员，不存在的成员将被忽略

详情说明 http://redisdoc.com/sorted_set/zrem.html

参数:

key - Key

members - 一个或多个成员

返回:

被成功移除的成员的数量，不包括被忽略的成员

zRem

public Long zRem(byte[] key,
                 byte[]... members)

从接口复制的说明: SortedSetCommands

移除有序集 key 中的一个或多个成员，不存在的成员将被忽略

详情说明 http://redisdoccom/sorted_set/zrem.html

参数:

key - Key

members - 一个或多个成员

返回:

被成功移除的成员的数量，不包括被忽略的成员

zRemRangeByLex

public Long zRemRangeByLex(String key,
                           String min,
                           String max)

从接口复制的说明: SortedSetCommands

对于一个所有成员的分值都相同的有序集合键 key 来说，这个命令会移除该集合中，成员介于 min 和 max 范围内的所有元素

详情说明 http://redisdoc.com/sorted_set/zremrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

被移除的元素数量

zRemRangeByLex

public Long zRemRangeByLex(byte[] key,
                           byte[] min,
                           byte[] max)

从接口复制的说明: SortedSetCommands

对于一个所有成员的分值都相同的有序集合键 key 来说，这个命令会移除该集合中，成员介于 min 和 max 范围内的所有元素

详情说明 http://redisdoc.com/sorted_set/zremrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

被移除的元素数量

zRemRangeByScore

public Long zRemRangeByScore(String key,
                             double min,
                             double max)

从接口复制的说明: SortedSetCommands

移除有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员

详情说明 http://redisdoc.com/sorted_set/zremrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

被移除成员的数量

zRemRangeByScore

public Long zRemRangeByScore(byte[] key,
                             double min,
                             double max)

从接口复制的说明: SortedSetCommands

移除有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员

详情说明 http://redisdoc.com/sorted_set/zremrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

被移除成员的数量

zRemRangeByScore

public Long zRemRangeByScore(String key,
                             String min,
                             String max)

从接口复制的说明: SortedSetCommands

移除有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员

详情说明 http://redisdoc.com/sorted_set/zremrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

被移除成员的数量

zRemRangeByScore

public Long zRemRangeByScore(byte[] key,
                             byte[] min,
                             byte[] max)

从接口复制的说明: SortedSetCommands

移除有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员

详情说明 http://redisdoc.com/sorted_set/zremrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

被移除成员的数量

zRemRangeByRank

public Long zRemRangeByRank(String key,
                            long start,
                            long end)

从接口复制的说明: SortedSetCommands

移除有序集 key 中，指定排名（rank）区间内的所有成员； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zremrangebyrank.html

参数:

key - Key

start - 开始排名

end - 结束排名

返回:

被移除成员的数量

zRemRangeByRank

public Long zRemRangeByRank(byte[] key,
                            long start,
                            long end)

从接口复制的说明: SortedSetCommands

移除有序集 key 中，指定排名（rank）区间内的所有成员； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zremrangebyrank.html

参数:

key - Key

start - 开始排名

end - 结束排名

返回:

被移除成员的数量

zRevRange

public List<String> zRevRange(String key,
                              long start,
                              long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zrevrange.html

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

指定区间内，有序集成员的列表； 当 start 的值比有序集的最大下标还要大，或是 start > end 时，返回一个空列表； 当 end 参数的值比有序集的最大下标还要大时，最多返回到 end

zRevRange

public List<byte[]> zRevRange(byte[] key,
                              long start,
                              long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，指定区间内的成员；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zrevrange.html

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

指定区间内，有序集成员的列表； 当 start 的值比有序集的最大下标还要大，或是 start > end 时，返回一个空列表； 当 end 参数的值比有序集的最大下标还要大时，最多返回到 end

zRevRangeWithScores

public List<Tuple> zRevRangeWithScores(String key,
                                       long start,
                                       long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 指定区间内的成员；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zrevrange.html

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

指定区间内，有序集成员的列表； 当 start 的值比有序集的最大下标还要大，或是 start > end 时，返回一个空列表； 当 end 参数的值比有序集的最大下标还要大时，最多返回到 end

zRevRangeWithScores

public List<Tuple> zRevRangeWithScores(byte[] key,
                                       long start,
                                       long end)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，带有 score 指定区间内的成员；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推

详情说明 http://redisdoc.com/sorted_set/zrevrange.html

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

指定区间内，有序集成员的列表； 当 start 的值比有序集的最大下标还要大，或是 start > end 时，返回一个空列表； 当 end 参数的值比有序集的最大下标还要大时，最多返回到 end

zRevRangeByLex

public List<String> zRevRangeByLex(String key,
                                   String min,
                                   String max)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员列表

zRevRangeByLex

public List<byte[]> zRevRangeByLex(byte[] key,
                                   byte[] min,
                                   byte[] max)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员列表

zRevRangeByLex

public List<String> zRevRangeByLex(String key,
                                   String min,
                                   String max,
                                   long offset,
                                   long count)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间从 offset 开始的 count 个成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内的成员列表

zRevRangeByLex

public List<byte[]> zRevRangeByLex(byte[] key,
                                   byte[] min,
                                   byte[] max,
                                   long offset,
                                   long count)

从接口复制的说明: SortedSetCommands

当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间从 offset 开始的 count 个成员

详情说明 http://redisdoc.com/sorted_set/zrangebylex.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内的成员列表

zRevRangeByScore

public List<String> zRevRangeByScore(String key,
                                     double min,
                                     double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRevRangeByScore

public List<byte[]> zRevRangeByScore(byte[] key,
                                     double min,
                                     double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRevRangeByScore

public List<String> zRevRangeByScore(String key,
                                     String min,
                                     String max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRevRangeByScore

public List<byte[]> zRevRangeByScore(byte[] key,
                                     byte[] min,
                                     byte[] max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRevRangeByScore

public List<String> zRevRangeByScore(String key,
                                     double min,
                                     double max,
                                     long offset,
                                     long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员的列表

zRevRangeByScore

public List<byte[]> zRevRangeByScore(byte[] key,
                                     double min,
                                     double max,
                                     long offset,
                                     long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员的列表

zRevRangeByScore

public List<String> zRevRangeByScore(String key,
                                     String min,
                                     String max,
                                     long offset,
                                     long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员的列表

zRevRangeByScore

public List<byte[]> zRevRangeByScore(byte[] key,
                                     byte[] min,
                                     byte[] max,
                                     long offset,
                                     long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员的列表

zRevRangeByScoreWithScores

public List<Tuple> zRevRangeByScoreWithScores(String key,
                                              double min,
                                              double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的带有 score 的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRevRangeByScoreWithScores

public List<Tuple> zRevRangeByScoreWithScores(byte[] key,
                                              double min,
                                              double max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的带有 score 的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRevRangeByScoreWithScores

public List<Tuple> zRevRangeByScoreWithScores(String key,
                                              String min,
                                              String max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的带有 score 的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRevRangeByScoreWithScores

public List<Tuple> zRevRangeByScoreWithScores(byte[] key,
                                              byte[] min,
                                              byte[] max)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的带有 score 的所有的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员的列表

zRevRangeByScoreWithScores

public List<Tuple> zRevRangeByScoreWithScores(String key,
                                              double min,
                                              double max,
                                              long offset,
                                              long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个带有 score 的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员的列表

zRevRangeByScoreWithScores

public List<Tuple> zRevRangeByScoreWithScores(byte[] key,
                                              double min,
                                              double max,
                                              long offset,
                                              long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个带有 score 的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员的列表

zRevRangeByScoreWithScores

public List<Tuple> zRevRangeByScoreWithScores(String key,
                                              String min,
                                              String max,
                                              long offset,
                                              long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个带有 score 的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员的列表

zRevRangeByScoreWithScores

public List<Tuple> zRevRangeByScoreWithScores(byte[] key,
                                              byte[] min,
                                              byte[] max,
                                              long offset,
                                              long count)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）从 offset 开始的 count 个带有 score 的成员； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列

详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员的列表

zRevRank

public Long zRevRank(String key,
                     String member)

从接口复制的说明: SortedSetCommands

获取有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减（从大到小）排序

详情说明 http://redisdoc.com/sorted_set/zrevrank.html

参数:

key - Key

member - member

返回:

如果 member 是有序集 key 的成员，返回 member 的排名； 如果 member 不是有序集 key 的成员，返回 null

zRevRank

public Long zRevRank(byte[] key,
                     byte[] member)

从接口复制的说明: SortedSetCommands

获取有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减（从大到小）排序

详情说明 http://redisdoc.com/sorted_set/zrevrank.html

参数:

key - Key

member - member

返回:

如果 member 是有序集 key 的成员，返回 member 的排名； 如果 member 不是有序集 key 的成员，返回 null

zScan

public ScanResult<List<Tuple>> zScan(String key,
                                     String cursor)

从接口复制的说明: SortedSetCommands

迭代有序集 key 中的键值对

详情说明 http://redisdoc.com/sorted_set/zscan.html

参数:

key - Key

cursor - 游标

返回:

返回的每个元素都是一个键值对

zScan

public ScanResult<List<Tuple>> zScan(byte[] key,
                                     byte[] cursor)

从接口复制的说明: SortedSetCommands

迭代有序集 key 中的键值对

详情说明 http://redisdoc.com/sorted_set/zscan.html

参数:

key - Key

cursor - 游标

返回:

返回的每个元素都是一个键值对

zScan

public ScanResult<List<Tuple>> zScan(String key,
                                     String cursor,
                                     String pattern)

从接口复制的说明: SortedSetCommands

迭代有序集 key 中的键值对

详情说明 http://redisdoc.com/sorted_set/zscan.html

参数:

key - Key

cursor - 游标

pattern - glob 风格的模式参数

返回:

返回和给定模式相匹配的元素

zScan

public ScanResult<List<Tuple>> zScan(byte[] key,
                                     byte[] cursor,
                                     byte[] pattern)

从接口复制的说明: SortedSetCommands

迭代有序集 key 中的键值对

详情说明 http://redisdoc.com/sorted_set/zscan.html

参数:

key - Key

cursor - 游标

pattern - glob 风格的模式参数

返回:

返回和给定模式相匹配的元素

zScan

public ScanResult<List<Tuple>> zScan(String key,
                                     String cursor,
                                     long count)

从接口复制的说明: SortedSetCommands

迭代有序集 key 中的键值对

详情说明 http://redisdoc.com/sorted_set/zscan.html

参数:

key - Key

cursor - 游标

count - 返回元素数量

返回:

返回的指定数量的键值对

zScan

public ScanResult<List<Tuple>> zScan(byte[] key,
                                     byte[] cursor,
                                     long count)

从接口复制的说明: SortedSetCommands

迭代有序集 key 中的键值对

详情说明 http://redisdoc.com/sorted_set/zscan.html

参数:

key - Key

cursor - 游标

count - 返回元素数量

返回:

返回的指定数量的键值对

zScan

public ScanResult<List<Tuple>> zScan(String key,
                                     String cursor,
                                     String pattern,
                                     long count)

从接口复制的说明: SortedSetCommands

迭代有序集 key 中的键值对

详情说明 http://redisdoc.com/sorted_set/zscan.html

参数:

key - Key

cursor - 游标

pattern - glob 风格的模式参数

count - 返回元素数量

返回:

返回和给定模式相匹配指定数量的元素

zScan

public ScanResult<List<Tuple>> zScan(byte[] key,
                                     byte[] cursor,
                                     byte[] pattern,
                                     long count)

从接口复制的说明: SortedSetCommands

迭代有序集 key 中的键值对

详情说明 http://redisdoc.com/sorted_set/zscan.html

参数:

key - Key

cursor - 游标

pattern - glob 风格的模式参数

count - 返回元素数量

返回:

返回和给定模式相匹配指定数量的元素

zScore

public Double zScore(String key,
                     String member)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，成员 member 的 score 值

详情说明 http://redisdoc.com/sorted_set/zscore.html

参数:

key - Key

member - member

返回:

member 成员的 score 值

zScore

public Double zScore(byte[] key,
                     byte[] member)

从接口复制的说明: SortedSetCommands

获取有序集 key 中，成员 member 的 score 值

详情说明 http://redisdoc.com/sorted_set/zscore.html

参数:

key - Key

member - member

返回:

member 成员的 score 值

zUnion

public Set<String> zUnion(String... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

返回:

集合的并集

zUnion

public Set<byte[]> zUnion(byte[]... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

返回:

集合的并集

zUnion

public Set<String> zUnion(String[] keys,
                          Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

返回:

集合的并集

zUnion

public Set<byte[]> zUnion(byte[][] keys,
                          Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

返回:

集合的并集

zUnion

public Set<String> zUnion(String[] keys,
                          double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

集合的并集

zUnion

public Set<byte[]> zUnion(byte[][] keys,
                          double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

集合的并集

zUnion

public Set<String> zUnion(String[] keys,
                          Aggregate aggregate,
                          double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

weights - 每个给定有序集的乘法因子

返回:

集合的并集

zUnion

public Set<byte[]> zUnion(byte[][] keys,
                          Aggregate aggregate,
                          double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

weights - 每个给定有序集的乘法因子

返回:

集合的并集

zUnionWithScores

public Set<Tuple> zUnionWithScores(String... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

返回:

带有分数的集合的并集

zUnionWithScores

public Set<Tuple> zUnionWithScores(byte[]... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

返回:

带有分数的集合的并集

zUnionWithScores

public Set<Tuple> zUnionWithScores(String[] keys,
                                   Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

返回:

带有分数的集合的并集

zUnionWithScores

public Set<Tuple> zUnionWithScores(byte[][] keys,
                                   Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

返回:

带有分数的集合的并集

zUnionWithScores

public Set<Tuple> zUnionWithScores(String[] keys,
                                   double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

带有分数的集合的并集

zUnionWithScores

public Set<Tuple> zUnionWithScores(byte[][] keys,
                                   double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

带有分数的集合的并集

zUnionWithScores

public Set<Tuple> zUnionWithScores(String[] keys,
                                   Aggregate aggregate,
                                   double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

weights - 每个给定有序集的乘法因子

返回:

带有分数的集合的并集

zUnionWithScores

public Set<Tuple> zUnionWithScores(byte[][] keys,
                                   Aggregate aggregate,
                                   double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集

详情说明 https://www.redis.com.cn/commands/zunion.html

参数:

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

weights - 每个给定有序集的乘法因子

返回:

带有分数的集合的并集

zUnionStore

public Long zUnionStore(String destKey,
                        String... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集，并将该并集储存到 destKey

详情说明 http://redisdoc.com/sorted_set/zunionstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

返回:

保存到 destKey 的结果集的基数

zUnionStore

public Long zUnionStore(byte[] destKey,
                        byte[]... keys)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集，并将该并集储存到 destKey

详情说明 http://redisdoc.com/sorted_set/zunionstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

返回:

保存到 destKey 的结果集的基数

zUnionStore

public Long zUnionStore(String destKey,
                        String[] keys,
                        Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集，并将该并集储存到 destKey

详情说明 http://redisdoc.com/sorted_set/zunionstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

返回:

保存到 destKey 的结果集的基数

zUnionStore

public Long zUnionStore(byte[] destKey,
                        byte[][] keys,
                        Aggregate aggregate)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集，并将该并集储存到 destKey

详情说明 http://redisdoc.com/sorted_set/zunionstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

返回:

保存到 destKey 的结果集的基数

zUnionStore

public Long zUnionStore(String destKey,
                        String[] keys,
                        double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集，并将该并集储存到 destKey

详情说明 http://redisdoc.com/sorted_set/zunionstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

保存到 destKey 的结果集的基数

zUnionStore

public Long zUnionStore(byte[] destKey,
                        byte[][] keys,
                        double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集，并将该并集储存到 destKey

详情说明 http://redisdoc.com/sorted_set/zunionstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

weights - 每个给定有序集的乘法因子

返回:

保存到 destKey 的结果集的基数

zUnionStore

public Long zUnionStore(String destKey,
                        String[] keys,
                        Aggregate aggregate,
                        double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集，并将该并集储存到 destKey

详情说明 http://redisdoc.com/sorted_set/zunionstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

weights - 每个给定有序集的乘法因子

返回:

保存到 destKey 的结果集的基数

zUnionStore

public Long zUnionStore(byte[] destKey,
                        byte[][] keys,
                        Aggregate aggregate,
                        double... weights)

从接口复制的说明: SortedSetCommands

计算给定的一个或多个有序集的并集，并将该并集储存到 destKey

详情说明 http://redisdoc.com/sorted_set/zunionstore.html

参数:

destKey - 目标 Key

keys - 一个或多个 Key

aggregate - 并集的结果集的聚合方式

weights - 每个给定有序集的乘法因子

返回:

保存到 destKey 的结果集的基数