com.buession.redis.core.operations

接口 SortedSetOperations

所有超级接口:

RedisCommands, RedisOperations, SortedSetCommands

所有已知实现类:

RedisTemplate

public interface SortedSetOperations
extends SortedSetCommands, RedisOperations

有序集合运算

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

作者:

Yong.Teng

方法概要

限定符和类型	方法和说明
default Long	zAdd(byte[] key, double score, byte[] member) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Long	zAdd(byte[] key, double score, byte[] member, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
default Long	zAdd(byte[] key, double score, byte[] member, GtLt gtLt) 将元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
default Long	zAdd(byte[] key, double score, byte[] member, GtLt gtLt, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
default Long	zAdd(byte[] key, double score, byte[] member, NxXx nxXx) 将元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
default Long	zAdd(byte[] key, double score, byte[] member, NxXx nxXx, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
default Long	zAdd(byte[] key, double score, byte[] member, NxXx nxXx, GtLt gtLt) 将元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
default Long	zAdd(byte[] key, double score, byte[] member, NxXx nxXx, GtLt gtLt, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 http://redisdoc.com/sorted_set/zadd.html
<V> Long	zAdd(byte[] key, double score, V member) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(byte[] key, double score, V member, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(byte[] key, double score, V member, GtLt gtLt) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(byte[] key, double score, V member, GtLt gtLt, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(byte[] key, double score, V member, NxXx nxXx) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(byte[] key, double score, V member, NxXx nxXx, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(byte[] key, double score, V member, NxXx nxXx, GtLt gtLt) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(byte[] key, double score, V member, NxXx nxXx, GtLt gtLt, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Long	zAdd(String key, double score, String member) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Long	zAdd(String key, double score, String member, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Long	zAdd(String key, double score, String member, GtLt gtLt) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Long	zAdd(String key, double score, String member, GtLt gtLt, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Long	zAdd(String key, double score, String member, NxXx nxXx) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Long	zAdd(String key, double score, String member, NxXx nxXx, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Long	zAdd(String key, double score, String member, NxXx nxXx, GtLt gtLt) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Long	zAdd(String key, double score, String member, NxXx nxXx, GtLt gtLt, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(String key, double score, V member) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(String key, double score, V member, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(String key, double score, V member, GtLt gtLt) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(String key, double score, V member, GtLt gtLt, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(String key, double score, V member, NxXx nxXx) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(String key, double score, V member, NxXx nxXx, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(String key, double score, V member, NxXx nxXx, GtLt gtLt) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
<V> Long	zAdd(String key, double score, V member, NxXx nxXx, GtLt gtLt, boolean ch) 将元素及其 score 值加入到有序集 key 当中 详情说明 https://www.redis.com.cn/commands/zadd.html
default Double	zDecr(byte[] key, byte[] member) 为有序集 key 的成员 member 的 score 值加上减量一
default Double	zDecr(String key, String member) 为有序集 key 的成员 member 的 score 值加上减量一
default Double	zDecrBy(byte[] key, double increment, byte[] member) 为有序集 key 的成员 member 的 score 值加上减量 increment 详情说明 http://redisdoc.com/sorted_set/zincrby.html
default Double	zDecrBy(String key, double increment, String member) 为有序集 key 的成员 member 的 score 值加上减量 increment 详情说明 http://redisdoc.com/sorted_set/zincrby.html
<V> Set<V>	zDiffObject(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/
<V> Set<V>	zDiffObject(byte[][] keys, Class<V> clazz) 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/
<V> Set<V>	zDiffObject(byte[][] keys, com.buession.core.serializer.type.TypeReference<V> type) 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/
<V> Set<V>	zDiffObject(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/
<V> Set<V>	zDiffObject(String[] keys, Class<V> clazz) 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/
<V> Set<V>	zDiffObject(String[] keys, com.buession.core.serializer.type.TypeReference<V> type) 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/
default Double	zIncr(byte[] key, byte[] member) 为有序集 key 的成员 member 的 score 值加上增量一
default Double	zIncr(String key, String member) 为有序集 key 的成员 member 的 score 值加上增量一
<V> Set<V>	zInterObject(byte[][] keys) 计算给定的一个或多个有序集合的交集，并反序列为对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, Aggregate aggregate) 计算给定的一个或多个有序集合的交集，并反序列化为对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, Aggregate aggregate, Class<V> clazz) 计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, Aggregate aggregate, double[] weights) 计算给定的一个或多个有序集合的交集，并反序列化为对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, Aggregate aggregate, double[] weights, Class<V> clazz) 计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, Aggregate aggregate, double[] weights, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, Aggregate aggregate, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, Class<V> clazz) 计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, double[] weights) 计算给定的一个或多个有序集合的交集，并反序列化为对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, double[] weights, Class<V> clazz) 计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, double[] weights, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(byte[][] keys, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys) 计算给定的一个或多个有序集合的交集，并反序列为对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, Aggregate aggregate) 计算给定的一个或多个有序集合的交集，并反序列化为对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, Aggregate aggregate, Class<V> clazz) 计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, Aggregate aggregate, double[] weights) 计算给定的一个或多个有序集合的交集，并反序列化为对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, Aggregate aggregate, double[] weights, Class<V> clazz) 计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, Aggregate aggregate, double[] weights, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, Aggregate aggregate, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, Class<V> clazz) 计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, double[] weights) 计算给定的一个或多个有序集合的交集，并反序列化对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, double[] weights, Class<V> clazz) 计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, double[] weights, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> Set<V>	zInterObject(String[] keys, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zinter/
<V> V	zRandMemberObject(byte[] key) 返回有序集合 key 中的一个随机元素，并反序列为对象 详情说明 https://redis.io/commands/zrandmember/
<V> V	zRandMemberObject(byte[] key, Class<V> clazz) 返回有序集合 key 中的一个随机元素，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zrandmember/
<V> List<V>	zRandMemberObject(byte[] key, long count) 返回有序集合 key 中的 count 个随机元素，并反序列为对象 详情说明 https://redis.io/commands/zrandmember/
<V> List<V>	zRandMemberObject(byte[] key, long count, Class<V> clazz) 返回有序集合 key 中的 count 个随机元素，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zrandmember/
<V> List<V>	zRandMemberObject(byte[] key, long count, com.buession.core.serializer.type.TypeReference<V> type) 返回有序集合 key 中的 count 个随机元素，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zrandmember/
<V> V	zRandMemberObject(byte[] key, com.buession.core.serializer.type.TypeReference<V> type) 返回有序集合 key 中的一个随机元素，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zrandmember/
<V> V	zRandMemberObject(String key) 返回有序集合 key 中的一个随机元素，并反序列为对象 详情说明 https://redis.io/commands/zrandmember/
<V> V	zRandMemberObject(String key, Class<V> clazz) 返回有序集合 key 中的一个随机元素，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zrandmember/
<V> List<V>	zRandMemberObject(String key, long count) 返回有序集合 key 中的 count 个随机元素，并反序列为对象 详情说明 https://redis.io/commands/zrandmember/
<V> List<V>	zRandMemberObject(String key, long count, Class<V> clazz) 返回有序集合 key 中的 count 个随机元素，并反序列化为 clazz 指定的对象 详情说明 https://redis.io/commands/zrandmember/
<V> List<V>	zRandMemberObject(String key, long count, com.buession.core.serializer.type.TypeReference<V> type) 返回有序集合 key 中的 count 个随机元素，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zrandmember/
<V> V	zRandMemberObject(String key, com.buession.core.serializer.type.TypeReference<V> type) 返回有序集合 key 中的一个随机元素，并反序列化为 type 指定的对象 详情说明 https://redis.io/commands/zrandmember/
<V> List<V>	zRangeByLexObject(byte[] key, byte[] min, byte[] max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(byte[] key, byte[] min, byte[] max, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(byte[] key, byte[] min, byte[] max, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(byte[] key, double min, double max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(byte[] key, double min, double max, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(byte[] key, double min, double max, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(String key, double min, double max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(String key, double min, double max, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(String key, double min, double max, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(String key, String min, String max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(String key, String min, String max, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByLexObject(String key, String min, String max, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRangeByScoreObject(byte[] key, byte[] min, byte[] max) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列为对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, byte[] min, byte[] max, Class<V> clazz) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, byte[] min, byte[] max, long offset, long count) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列为对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, byte[] min, byte[] max, long offset, long count, Class<V> clazz) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, byte[] min, byte[] max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, byte[] min, byte[] max, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, double min, double max) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列为对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, double min, double max, Class<V> clazz) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, double min, double max, long offset, long count) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列为对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, double min, double max, long offset, long count, Class<V> clazz) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, double min, double max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(byte[] key, double min, double max, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, double min, double max) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列为对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, double min, double max, Class<V> clazz) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, double min, double max, long offset, long count) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列为对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, double min, double max, long offset, long count, Class<V> clazz) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, double min, double max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, double min, double max, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, String min, String max) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列为对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, String min, String max, Class<V> clazz) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, String min, String max, long offset, long count) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列为对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, String min, String max, long offset, long count, Class<V> clazz) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, String min, String max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeByScoreObject(String key, String min, String max, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，所有 score 值介于 min 和 max 之间（包括等于 min 或 max ）的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递增（从小到大）次序排列，具有相同 score 值的成员按字典序排列 详情说明 http://redisdoc.com/sorted_set/zrangebyscore.html
<V> List<V>	zRangeObject(byte[] key, long start, long end) 获取有序集 key 中，指定区间内的成员，并反序列为对象；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
<V> List<V>	zRangeObject(byte[] key, long start, long end, Class<V> clazz) 获取有序集 key 中，指定区间内的成员，并反序列化为 clazz 指定的对象；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
<V> List<V>	zRangeObject(byte[] key, long start, long end, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，指定区间内的成员，并反序列化为 type 指定的对象；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
<V> List<V>	zRangeObject(String key, long start, long end) 获取有序集 key 中，指定区间内的成员，并反序列为对象；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
<V> List<V>	zRangeObject(String key, long start, long end, Class<V> clazz) 获取有序集 key 中，指定区间内的成员，并反序列化为 clazz 指定的对象；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
<V> List<V>	zRangeObject(String key, long start, long end, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，指定区间内的成员，并反序列化为 type 指定的对象；其中成员的位置按 score 值递增(从小到大)来排序； 具有相同 score 值的成员按字典序来排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrange.html
default long	zRem(byte[] key, byte[] member) 移除有序集 key 中的成员，不存在的成员将被忽略 详情说明 http://redisdoccom/sorted_set/zrem.html
default long	zRem(String key, String member) 移除有序集 key 中的成员，不存在的成员将被忽略 详情说明 http://redisdoccom/sorted_set/zrem.html
<V> List<V>	zRevRangeByLexObject(byte[] key, byte[] min, byte[] max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, byte[] min, byte[] max, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, byte[] min, byte[] max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, byte[] min, byte[] max, long offset, long count, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, byte[] min, byte[] max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, byte[] min, byte[] max, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, double min, double max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, double min, double max, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, double min, double max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, double min, double max, long offset, long count, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, double min, double max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(byte[] key, double min, double max, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, double min, double max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, double min, double max, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, double min, double max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, double min, double max, long offset, long count, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, double min, double max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, double min, double max, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, String min, String max) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, String min, String max, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, String min, String max, long offset, long count) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列为对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, String min, String max, long offset, long count, Class<V> clazz) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 clazz 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, String min, String max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByLexObject(String key, String min, String max, com.buession.core.serializer.type.TypeReference<V> type) 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的字典序来进行排序， 而这个命令则可以返回给定的有序集合键 key 中，值介于 min 和 max 之间的成员，并反序列化为 type 指定的对象 详情说明 http://redisdoc.com/sorted_set/zrangebylex.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, byte[] min, byte[] max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列为对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, byte[] min, byte[] max, Class<V> clazz) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, byte[] min, byte[] max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列为对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, byte[] min, byte[] max, long offset, long count, Class<V> clazz) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, byte[] min, byte[] max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, byte[] min, byte[] max, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, double min, double max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列为对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, double min, double max, Class<V> clazz) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, double min, double max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列为对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, double min, double max, long offset, long count, Class<V> clazz) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, double min, double max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(byte[] key, double min, double max, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, double min, double max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列为对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, double min, double max, Class<V> clazz) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, double min, double max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列为对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, double min, double max, long offset, long count, Class<V> clazz) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, double min, double max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, double min, double max, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, String min, String max) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列为对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, String min, String max, Class<V> clazz) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, String min, String max, long offset, long count) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列为对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, String min, String max, long offset, long count, Class<V> clazz) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 clazz 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, String min, String max, long offset, long count, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeByScoreObject(String key, String min, String max, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，score 值介于 min 和 max 之间（包括等于 min 或 max ）的所有的成员，并反序列化为 type 指定的对象； 有序集成员按 score 值递减（从大到小）的次序排列； 具有相同 score 值的成员按字典序的逆序排列 详情说明 http://redisdoc.com/sorted_set/zrevrangebyscore.html
<V> List<V>	zRevRangeObject(byte[] key, long start, long end) 获取有序集 key 中，指定区间内的成员，并反序列为对象；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
<V> List<V>	zRevRangeObject(byte[] key, long start, long end, Class<V> clazz) 获取有序集 key 中，指定区间内的成员，并反序列化为 clazz 指定的对象；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
<V> List<V>	zRevRangeObject(byte[] key, long start, long end, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，指定区间内的成员，并反序列化为 type 指定的对象；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
<V> List<V>	zRevRangeObject(String key, long start, long end) 获取有序集 key 中，指定区间内的成员，并反序列为对象；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
<V> List<V>	zRevRangeObject(String key, long start, long end, Class<V> clazz) 获取有序集 key 中，指定区间内的成员，并反序列化为 clazz 指定的对象；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
<V> List<V>	zRevRangeObject(String key, long start, long end, com.buession.core.serializer.type.TypeReference<V> type) 获取有序集 key 中，指定区间内的成员，并反序列化为 type 指定的对象；其中成员的位置按 score 值递减（从大到小）来排列； 具有相同 score 值的成员按字典序的逆序排列； 也可以使用负数下标，以 -1 表示最后一个成员，-2 表示倒数第二个成员，以此类推 详情说明 http://redisdoc.com/sorted_set/zrevrange.html
<V> Set<V>	zUnionObject(byte[][] keys) 计算给定的一个或多个有序集的并集，并反序列为对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, Aggregate aggregate) 计算给定的一个或多个有序集的并集，并反序列为对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, Aggregate aggregate, Class<V> clazz) 计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, Aggregate aggregate, double[] weights) 计算给定的一个或多个有序集的并集，并反序列为对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, Aggregate aggregate, double[] weights, Class<V> clazz) 计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, Aggregate aggregate, double[] weights, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, Aggregate aggregate, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, Class<V> clazz) 计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, double[] weights) 计算给定的一个或多个有序集的并集，并反序列为对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, double[] weights, Class<V> clazz) 计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, double[] weights, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(byte[][] keys, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys) 计算给定的一个或多个有序集的并集，并反序列为对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, Aggregate aggregate) 计算给定的一个或多个有序集的并集，并反序列为对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, Aggregate aggregate, Class<V> clazz) 计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, Aggregate aggregate, double[] weights) 计算给定的一个或多个有序集的并集，并反序列为对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, Aggregate aggregate, double[] weights, Class<V> clazz) 计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, Aggregate aggregate, double[] weights, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, Aggregate aggregate, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, Class<V> clazz) 计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, double[] weights) 计算给定的一个或多个有序集的并集，并反序列为对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, double[] weights, Class<V> clazz) 计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, double[] weights, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html
<V> Set<V>	zUnionObject(String[] keys, com.buession.core.serializer.type.TypeReference<V> type) 计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象 详情说明 https://www.redis.com.cn/commands/zunion.html

从接口继承的方法 com.buession.redis.core.command.SortedSetCommands

bzPopMax, bzPopMax, bzPopMin, bzPopMin, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zAdd, zCard, zCard, zCount, zCount, zCount, zCount, zDiff, zDiff, zDiffStore, zDiffStore, zDiffWithScores, zDiffWithScores, zIncrBy, zIncrBy, zInter, zInter, zInter, zInter, zInter, zInter, zInter, zInter, zInterStore, zInterStore, zInterStore, zInterStore, zInterStore, zInterStore, zInterStore, zInterStore, zInterWithScores, zInterWithScores, zInterWithScores, zInterWithScores, zInterWithScores, zInterWithScores, zInterWithScores, zInterWithScores, zLexCount, zLexCount, zLexCount, zLexCount, zMScore, zMScore, zPopMax, zPopMax, zPopMax, zPopMax, zPopMin, zPopMin, zPopMin, zPopMin, zRandMember, zRandMember, zRandMember, zRandMember, zRandMemberWithScores, zRandMemberWithScores, zRange, zRange, zRangeByLex, zRangeByLex, zRangeByLex, zRangeByLex, zRangeByLex, zRangeByLex, zRangeByLex, zRangeByLex, zRangeByScore, zRangeByScore, zRangeByScore, zRangeByScore, zRangeByScore, zRangeByScore, zRangeByScore, zRangeByScore, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeStore, zRangeWithScores, zRangeWithScores, zRank, zRank, zRem, zRem, zRemRangeByLex, zRemRangeByLex, zRemRangeByLex, zRemRangeByLex, zRemRangeByRank, zRemRangeByRank, zRemRangeByScore, zRemRangeByScore, zRemRangeByScore, zRemRangeByScore, zRevRange, zRevRange, zRevRangeByLex, zRevRangeByLex, zRevRangeByLex, zRevRangeByLex, zRevRangeByLex, zRevRangeByLex, zRevRangeByLex, zRevRangeByLex, zRevRangeByScore, zRevRangeByScore, zRevRangeByScore, zRevRangeByScore, zRevRangeByScore, zRevRangeByScore, zRevRangeByScore, zRevRangeByScore, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores, zRevRangeWithScores, zRevRangeWithScores, zRevRank, zRevRank, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScan, zScore, zScore, zUnion, zUnion, zUnion, zUnion, zUnion, zUnion, zUnion, zUnion, zUnionStore, zUnionStore, zUnionStore, zUnionStore, zUnionStore, zUnionStore, zUnionStore, zUnionStore, zUnionWithScores, zUnionWithScores, zUnionWithScores, zUnionWithScores, zUnionWithScores, zUnionWithScores, zUnionWithScores, zUnionWithScores

方法详细资料

zAdd

default Long zAdd(String key,
                  double score,
                  String member)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

返回:

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

zAdd

default Long zAdd(byte[] key,
                  double score,
                  byte[] member)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

返回:

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

zAdd

default Long zAdd(String key,
                  double score,
                  String member,
                  NxXx nxXx)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

default Long zAdd(byte[] key,
                  double score,
                  byte[] member,
                  NxXx nxXx)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

default Long zAdd(String key,
                  double score,
                  String member,
                  GtLt gtLt)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

default Long zAdd(byte[] key,
                  double score,
                  byte[] member,
                  GtLt gtLt)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

default Long zAdd(String key,
                  double score,
                  String member,
                  boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

default Long zAdd(byte[] key,
                  double score,
                  byte[] member,
                  boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

default Long zAdd(String key,
                  double score,
                  String member,
                  NxXx nxXx,
                  GtLt gtLt)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

default Long zAdd(byte[] key,
                  double score,
                  byte[] member,
                  NxXx nxXx,
                  GtLt gtLt)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

default Long zAdd(String key,
                  double score,
                  String member,
                  NxXx nxXx,
                  boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

default Long zAdd(byte[] key,
                  double score,
                  byte[] member,
                  NxXx nxXx,
                  boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

default Long zAdd(String key,
                  double score,
                  String member,
                  GtLt gtLt,
                  boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

default Long zAdd(byte[] key,
                  double score,
                  byte[] member,
                  GtLt gtLt,
                  boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

default Long zAdd(String key,
                  double score,
                  String member,
                  NxXx nxXx,
                  GtLt gtLt,
                  boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

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

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

返回:

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

zAdd

default Long zAdd(byte[] key,
                  double score,
                  byte[] member,
                  NxXx nxXx,
                  GtLt gtLt,
                  boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

参数:

key - Key

score - score

member - 元素

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

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

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

返回:

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

zAdd

<V> Long zAdd(String key,
              double score,
              V member)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

返回:

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

zAdd

<V> Long zAdd(byte[] key,
              double score,
              V member)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

返回:

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

zAdd

<V> Long zAdd(String key,
              double score,
              V member,
              NxXx nxXx)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

<V> Long zAdd(byte[] key,
              double score,
              V member,
              NxXx nxXx)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

<V> Long zAdd(String key,
              double score,
              V member,
              GtLt gtLt)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

<V> Long zAdd(byte[] key,
              double score,
              V member,
              GtLt gtLt)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

<V> Long zAdd(String key,
              double score,
              V member,
              boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

<V> Long zAdd(byte[] key,
              double score,
              V member,
              boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

返回:

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

zAdd

<V> Long zAdd(String key,
              double score,
              V member,
              NxXx nxXx,
              GtLt gtLt)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

<V> Long zAdd(byte[] key,
              double score,
              V member,
              NxXx nxXx,
              GtLt gtLt)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

<V> Long zAdd(String key,
              double score,
              V member,
              NxXx nxXx,
              boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

<V> Long zAdd(byte[] key,
              double score,
              V member,
              NxXx nxXx,
              boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

<V> Long zAdd(String key,
              double score,
              V member,
              GtLt gtLt,
              boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

<V> Long zAdd(byte[] key,
              double score,
              V member,
              GtLt gtLt,
              boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

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

返回:

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

zAdd

<V> Long zAdd(String key,
              double score,
              V member,
              NxXx nxXx,
              GtLt gtLt,
              boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

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

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

返回:

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

zAdd

<V> Long zAdd(byte[] key,
              double score,
              V member,
              NxXx nxXx,
              GtLt gtLt,
              boolean ch)

将元素及其 score 值加入到有序集 key 当中

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

类型参数:

V - 元素值类型

参数:

key - Key

score - score

member - 元素

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

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

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

返回:

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

zDiffObject

<V> Set<V> zDiffObject(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/

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

返回:

The result of the difference

zDiffObject

<V> Set<V> zDiffObject(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/

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

返回:

The result of the difference

zDiffObject

<V> Set<V> zDiffObject(String[] keys,
                       Class<V> clazz)

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/

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

clazz - 值对象类

返回:

The result of the difference

zDiffObject

<V> Set<V> zDiffObject(byte[][] keys,
                       Class<V> clazz)

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/

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

clazz - 值对象类

返回:

The result of the difference

zDiffObject

<V> Set<V> zDiffObject(String[] keys,
                       com.buession.core.serializer.type.TypeReference<V> type)

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/

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

type - 值类型引用

返回:

The result of the difference

另请参阅:

TypeReference

zDiffObject

<V> Set<V> zDiffObject(byte[][] keys,
                       com.buession.core.serializer.type.TypeReference<V> type)

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/

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

type - 值类型引用

返回:

The result of the difference

另请参阅:

TypeReference

zIncr

default Double zIncr(String key,
                     String member)

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

参数:

key - Key

member - member 元素

返回:

member 成员的新 score 值

zIncr

default Double zIncr(byte[] key,
                     byte[] member)

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

参数:

key - Key

member - member 元素

返回:

member 成员的新 score 值

zDecr

default Double zDecr(String key,
                     String member)

为有序集 key 的成员 member 的 score 值加上减量一

参数:

key - Key

member - member 元素

返回:

member 成员的新 score 值

zDecr

default Double zDecr(byte[] key,
                     byte[] member)

为有序集 key 的成员 member 的 score 值加上减量一

参数:

key - Key

member - member 元素

返回:

member 成员的新 score 值

zDecrBy

default Double zDecrBy(String key,
                       double increment,
                       String member)

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

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

参数:

key - Key

increment - 增量

member - member 元素

返回:

member 成员的新 score 值

zDecrBy

default Double zDecrBy(byte[] key,
                       double increment,
                       byte[] member)

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

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

参数:

key - Key

increment - 增量

member - member 元素

返回:

member 成员的新 score 值

zInterObject

<V> Set<V> zInterObject(String[] keys)

计算给定的一个或多个有序集合的交集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(byte[][] keys)

计算给定的一个或多个有序集合的交集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        Class<V> clazz)

计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

clazz - 值对象类

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        Class<V> clazz)

计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

clazz - 值对象类

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

type - 值类型引用

返回:

有序集合的交集反序列为对象

另请参阅:

TypeReference

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

type - 值类型引用

返回:

有序集合的交集反序列为对象

另请参阅:

TypeReference

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        Aggregate aggregate)

计算给定的一个或多个有序集合的交集，并反序列化为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        Aggregate aggregate)

计算给定的一个或多个有序集合的交集，并反序列化为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        Aggregate aggregate,
                        Class<V> clazz)

计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

clazz - 值对象类

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        Aggregate aggregate,
                        Class<V> clazz)

计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

clazz - 值对象类

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        Aggregate aggregate,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

type - 值类型引用

返回:

有序集合的交集反序列为对象

另请参阅:

TypeReference

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        Aggregate aggregate,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

type - 值类型引用

返回:

有序集合的交集反序列为对象

另请参阅:

TypeReference

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        double[] weights)

计算给定的一个或多个有序集合的交集，并反序列化对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        double[] weights)

计算给定的一个或多个有序集合的交集，并反序列化为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        double[] weights,
                        Class<V> clazz)

计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

clazz - 值对象类

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        double[] weights,
                        Class<V> clazz)

计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

clazz - 值对象类

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        double[] weights,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

type - 值类型引用

返回:

有序集合的交集反序列为对象

另请参阅:

TypeReference

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        double[] weights,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

type - 值类型引用

返回:

有序集合的交集反序列为对象

另请参阅:

TypeReference

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        Aggregate aggregate,
                        double[] weights)

计算给定的一个或多个有序集合的交集，并反序列化为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

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

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        Aggregate aggregate,
                        double[] weights)

计算给定的一个或多个有序集合的交集，并反序列化为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

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

返回:

The result of intersection

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        Aggregate aggregate,
                        double[] weights,
                        Class<V> clazz)

计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

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

clazz - 值对象类

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        Aggregate aggregate,
                        double[] weights,
                        Class<V> clazz)

计算给定的一个或多个有序集合的交集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

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

clazz - 值对象类

返回:

有序集合的交集反序列为对象

zInterObject

<V> Set<V> zInterObject(String[] keys,
                        Aggregate aggregate,
                        double[] weights,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

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

type - 值类型引用

返回:

有序集合的交集反序列为对象

另请参阅:

TypeReference

zInterObject

<V> Set<V> zInterObject(byte[][] keys,
                        Aggregate aggregate,
                        double[] weights,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集合的交集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

aggregate - Aggregate

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

type - 值类型引用

返回:

The result of intersection

另请参阅:

TypeReference

zRandMemberObject

<V> V zRandMemberObject(String key)

返回有序集合 key 中的一个随机元素，并反序列为对象

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

类型参数:

V - 值类型

参数:

key - Key

返回:

有序集合 key 中的一个随机元素反序列化后的对象

zRandMemberObject

<V> V zRandMemberObject(byte[] key)

返回有序集合 key 中的一个随机元素，并反序列为对象

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

类型参数:

V - 值类型

参数:

key - Key

返回:

有序集合 key 中的一个随机元素反序列化后的对象

zRandMemberObject

<V> V zRandMemberObject(String key,
                        Class<V> clazz)

返回有序集合 key 中的一个随机元素，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

key - Key

clazz - 值对象类

返回:

有序集合 key 中的一个随机元素反序列化后的对象

zRandMemberObject

<V> V zRandMemberObject(byte[] key,
                        Class<V> clazz)

返回有序集合 key 中的一个随机元素，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

key - Key

clazz - 值对象类

返回:

有序集合 key 中的一个随机元素反序列化后的对象

zRandMemberObject

<V> V zRandMemberObject(String key,
                        com.buession.core.serializer.type.TypeReference<V> type)

返回有序集合 key 中的一个随机元素，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

key - Key

type - 值类型引用

返回:

有序集合 key 中的一个随机元素反序列化后的对象

另请参阅:

TypeReference

zRandMemberObject

<V> V zRandMemberObject(byte[] key,
                        com.buession.core.serializer.type.TypeReference<V> type)

返回有序集合 key 中的一个随机元素，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

key - Key

type - 值类型引用

返回:

有序集合 key 中的一个随机元素反序列化后的对象

另请参阅:

TypeReference

zRandMemberObject

<V> List<V> zRandMemberObject(String key,
                              long count)

返回有序集合 key 中的 count 个随机元素，并反序列为对象

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

类型参数:

V - 值类型

参数:

key - Key

count - 需要返回的元素数量

返回:

有序集合 key 中的随机元素反序列化后的对象

zRandMemberObject

<V> List<V> zRandMemberObject(byte[] key,
                              long count)

返回有序集合 key 中的 count 个随机元素，并反序列为对象

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

类型参数:

V - 值类型

参数:

key - Key

count - 需要返回的元素数量

返回:

有序集合 key 中的随机元素反序列化后的对象

zRandMemberObject

<V> List<V> zRandMemberObject(String key,
                              long count,
                              Class<V> clazz)

返回有序集合 key 中的 count 个随机元素，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

key - Key

count - 需要返回的元素数量

clazz - 值对象类

返回:

有序集合 key 中的随机元素反序列化后的对象

zRandMemberObject

<V> List<V> zRandMemberObject(byte[] key,
                              long count,
                              Class<V> clazz)

返回有序集合 key 中的 count 个随机元素，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

key - Key

count - 需要返回的元素数量

clazz - 值对象类

返回:

有序集合 key 中的随机元素反序列化后的对象

zRandMemberObject

<V> List<V> zRandMemberObject(String key,
                              long count,
                              com.buession.core.serializer.type.TypeReference<V> type)

返回有序集合 key 中的 count 个随机元素，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

key - Key

count - 需要返回的元素数量

type - 值类型引用

返回:

有序集合 key 中的随机元素反序列化后的对象

另请参阅:

TypeReference

zRandMemberObject

<V> List<V> zRandMemberObject(byte[] key,
                              long count,
                              com.buession.core.serializer.type.TypeReference<V> type)

返回有序集合 key 中的 count 个随机元素，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

key - Key

count - 需要返回的元素数量

type - 值类型引用

返回:

有序集合 key 中的随机元素反序列化后的对象

另请参阅:

TypeReference

zRangeObject

<V> List<V> zRangeObject(String key,
                         long start,
                         long end)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

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

zRangeObject

<V> List<V> zRangeObject(byte[] key,
                         long start,
                         long end)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

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

zRangeObject

<V> List<V> zRangeObject(String key,
                         long start,
                         long end,
                         Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

clazz - 值对象类

返回:

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

zRangeObject

<V> List<V> zRangeObject(byte[] key,
                         long start,
                         long end,
                         Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

clazz - 值对象类

返回:

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

zRangeObject

<V> List<V> zRangeObject(String key,
                         long start,
                         long end,
                         com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

type - 值类型引用

返回:

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

另请参阅:

TypeReference

zRangeObject

<V> List<V> zRangeObject(byte[] key,
                         long start,
                         long end,
                         com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

type - 值类型引用

返回:

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

另请参阅:

TypeReference

zRangeByLexObject

<V> List<V> zRangeByLexObject(String key,
                              double min,
                              double max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

zRangeByLexObject

<V> List<V> zRangeByLexObject(byte[] key,
                              double min,
                              double max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

zRangeByLexObject

<V> List<V> zRangeByLexObject(String key,
                              double min,
                              double max,
                              Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

zRangeByLexObject

<V> List<V> zRangeByLexObject(byte[] key,
                              double min,
                              double max,
                              Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

zRangeByLexObject

<V> List<V> zRangeByLexObject(String key,
                              double min,
                              double max,
                              com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

另请参阅:

TypeReference

zRangeByLexObject

<V> List<V> zRangeByLexObject(byte[] key,
                              double min,
                              double max,
                              com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

另请参阅:

TypeReference

zRangeByLexObject

<V> List<V> zRangeByLexObject(String key,
                              String min,
                              String max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

zRangeByLexObject

<V> List<V> zRangeByLexObject(byte[] key,
                              byte[] min,
                              byte[] max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

zRangeByLexObject

<V> List<V> zRangeByLexObject(String key,
                              String min,
                              String max,
                              Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

zRangeByLexObject

<V> List<V> zRangeByLexObject(byte[] key,
                              byte[] min,
                              byte[] max,
                              Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

zRangeByLexObject

<V> List<V> zRangeByLexObject(String key,
                              String min,
                              String max,
                              com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

另请参阅:

TypeReference

zRangeByLexObject

<V> List<V> zRangeByLexObject(byte[] key,
                              byte[] min,
                              byte[] max,
                              com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

包含了有序集合在指定范围内的成员反序列化为对象后的列表

另请参阅:

TypeReference

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                double min,
                                double max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                double min,
                                double max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                double min,
                                double max,
                                Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                double min,
                                double max,
                                Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                double min,
                                double max,
                                com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                double min,
                                double max,
                                com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                String min,
                                String max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                byte[] min,
                                byte[] max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                String min,
                                String max,
                                Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                byte[] min,
                                byte[] max,
                                Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                String min,
                                String max,
                                com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                byte[] min,
                                byte[] max,
                                com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                double min,
                                double max,
                                long offset,
                                long count)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

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

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                double min,
                                double max,
                                long offset,
                                long count,
                                Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                double min,
                                double max,
                                long offset,
                                long count,
                                Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                double min,
                                double max,
                                long offset,
                                long count,
                                com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                double min,
                                double max,
                                long offset,
                                long count,
                                com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                String min,
                                String max,
                                long offset,
                                long count)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                byte[] min,
                                byte[] max,
                                long offset,
                                long count)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                String min,
                                String max,
                                long offset,
                                long count,
                                Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                byte[] min,
                                byte[] max,
                                long offset,
                                long count,
                                Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(String key,
                                String min,
                                String max,
                                long offset,
                                long count,
                                com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRangeByScoreObject

<V> List<V> zRangeByScoreObject(byte[] key,
                                byte[] min,
                                byte[] max,
                                long offset,
                                long count,
                                com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRem

default long zRem(String key,
                  String member)

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

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

参数:

key - Key

member - 成员

返回:

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

zRem

default long zRem(byte[] key,
                  byte[] member)

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

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

参数:

key - Key

member - 成员

返回:

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

zRevRangeObject

<V> List<V> zRevRangeObject(String key,
                            long start,
                            long end)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

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

zRevRangeObject

<V> List<V> zRevRangeObject(byte[] key,
                            long start,
                            long end)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

返回:

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

zRevRangeObject

<V> List<V> zRevRangeObject(String key,
                            long start,
                            long end,
                            Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

clazz - 值对象类

返回:

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

zRevRangeObject

<V> List<V> zRevRangeObject(byte[] key,
                            long start,
                            long end,
                            Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

clazz - 值对象类

返回:

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

zRevRangeObject

<V> List<V> zRevRangeObject(String key,
                            long start,
                            long end,
                            com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

type - 值类型引用

返回:

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

另请参阅:

TypeReference

zRevRangeObject

<V> List<V> zRevRangeObject(byte[] key,
                            long start,
                            long end,
                            com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

start - 开始位置

end - 结束位置

type - 值类型引用

返回:

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

另请参阅:

TypeReference

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 double min,
                                 double max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 double min,
                                 double max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 double min,
                                 double max,
                                 Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 double min,
                                 double max,
                                 Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 double min,
                                 double max,
                                 com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

另请参阅:

TypeReference

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 double min,
                                 double max,
                                 com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

另请参阅:

TypeReference

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 String min,
                                 String max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 byte[] min,
                                 byte[] max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 String min,
                                 String max,
                                 Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 byte[] min,
                                 byte[] max,
                                 Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 String min,
                                 String max,
                                 com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

另请参阅:

TypeReference

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 byte[] min,
                                 byte[] max,
                                 com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

另请参阅:

TypeReference

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 double min,
                                 double max,
                                 long offset,
                                 long count)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

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

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 double min,
                                 double max,
                                 long offset,
                                 long count,
                                 Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

clazz - 值对象类

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 double min,
                                 double max,
                                 long offset,
                                 long count,
                                 Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

clazz - 值对象类

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 double min,
                                 double max,
                                 long offset,
                                 long count,
                                 com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

type - 值类型引用

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

另请参阅:

TypeReference

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 double min,
                                 double max,
                                 long offset,
                                 long count,
                                 com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

type - 值类型引用

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

另请参阅:

TypeReference

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 String min,
                                 String max,
                                 long offset,
                                 long count)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 byte[] min,
                                 byte[] max,
                                 long offset,
                                 long count)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 String min,
                                 String max,
                                 long offset,
                                 long count,
                                 Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

clazz - 值对象类

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 byte[] min,
                                 byte[] max,
                                 long offset,
                                 long count,
                                 Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

clazz - 值对象类

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(String key,
                                 String min,
                                 String max,
                                 long offset,
                                 long count,
                                 com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

type - 值类型引用

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

另请参阅:

TypeReference

zRevRangeByLexObject

<V> List<V> zRevRangeByLexObject(byte[] key,
                                 byte[] min,
                                 byte[] max,
                                 long offset,
                                 long count,
                                 com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回个数

type - 值类型引用

返回:

包含了有序集合在指定范围内反序列化为对象后的成员列表

另请参阅:

TypeReference

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   double min,
                                   double max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   double min,
                                   double max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   double min,
                                   double max,
                                   Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   double min,
                                   double max,
                                   Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   double min,
                                   double max,
                                   com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   double min,
                                   double max,
                                   com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   String min,
                                   String max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   byte[] min,
                                   byte[] max)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   String min,
                                   String max,
                                   Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   byte[] min,
                                   byte[] max,
                                   Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   String min,
                                   String max,
                                   com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   byte[] min,
                                   byte[] max,
                                   com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   double min,
                                   double max,
                                   long offset,
                                   long count)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

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

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   double min,
                                   double max,
                                   long offset,
                                   long count,
                                   Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   double min,
                                   double max,
                                   long offset,
                                   long count,
                                   Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   double min,
                                   double max,
                                   long offset,
                                   long count,
                                   com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   double min,
                                   double max,
                                   long offset,
                                   long count,
                                   com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   String min,
                                   String max,
                                   long offset,
                                   long count)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   byte[] min,
                                   byte[] max,
                                   long offset,
                                   long count)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   String min,
                                   String max,
                                   long offset,
                                   long count,
                                   Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   byte[] min,
                                   byte[] max,
                                   long offset,
                                   long count,
                                   Class<V> clazz)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

clazz - 值对象类

返回:

指定区间内，有序集成员反序列化为对象的列表

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(String key,
                                   String min,
                                   String max,
                                   long offset,
                                   long count,
                                   com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zRevRangeByScoreObject

<V> List<V> zRevRangeByScoreObject(byte[] key,
                                   byte[] min,
                                   byte[] max,
                                   long offset,
                                   long count,
                                   com.buession.core.serializer.type.TypeReference<V> type)

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

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

类型参数:

V - 值类型

参数:

key - Key

min - 最小 score

max - 最大 score

offset - 偏移量

count - 返回数量

type - 值类型引用

返回:

指定区间内，有序集成员反序列化为对象的列表

另请参阅:

TypeReference

zUnionObject

<V> Set<V> zUnionObject(String[] keys)

计算给定的一个或多个有序集的并集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

返回:

反序列化为对象后的集合并集

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys)

计算给定的一个或多个有序集的并集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

返回:

反序列化为对象后的集合并集

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        Class<V> clazz)

计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

clazz - 值对象类

返回:

反序列化为对象后的集合并集

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        Class<V> clazz)

计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

clazz - 值对象类

返回:

反序列化为对象后的集合并集

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

type - 值类型引用

返回:

反序列化为对象后的集合并集

另请参阅:

TypeReference

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

type - 值类型引用

返回:

反序列化为对象后的集合并集

另请参阅:

TypeReference

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        Aggregate aggregate)

计算给定的一个或多个有序集的并集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        Aggregate aggregate)

计算给定的一个或多个有序集的并集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        Aggregate aggregate,
                        Class<V> clazz)

计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

clazz - 值对象类

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        Aggregate aggregate,
                        Class<V> clazz)

计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

clazz - 值对象类

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        Aggregate aggregate,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

type - 值类型引用

返回:

并集成员反序列化为对象的列表

另请参阅:

TypeReference

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        Aggregate aggregate,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

type - 值类型引用

返回:

并集成员反序列化为对象的列表

另请参阅:

TypeReference

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        double[] weights)

计算给定的一个或多个有序集的并集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        double[] weights)

计算给定的一个或多个有序集的并集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        double[] weights,
                        Class<V> clazz)

计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

clazz - 值对象类

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        double[] weights,
                        Class<V> clazz)

计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

clazz - 值对象类

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        double[] weights,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

type - 值类型引用

返回:

并集成员反序列化为对象的列表

另请参阅:

TypeReference

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        double[] weights,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

type - 值类型引用

返回:

并集成员反序列化为对象的列表

另请参阅:

TypeReference

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        Aggregate aggregate,
                        double[] weights)

计算给定的一个或多个有序集的并集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

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

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        Aggregate aggregate,
                        double[] weights)

计算给定的一个或多个有序集的并集，并反序列为对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

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

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        Aggregate aggregate,
                        double[] weights,
                        Class<V> clazz)

计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

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

clazz - 值对象类

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        Aggregate aggregate,
                        double[] weights,
                        Class<V> clazz)

计算给定的一个或多个有序集的并集，并反序列化为 clazz 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

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

clazz - 值对象类

返回:

并集成员反序列化为对象的列表

zUnionObject

<V> Set<V> zUnionObject(String[] keys,
                        Aggregate aggregate,
                        double[] weights,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

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

type - 值类型引用

返回:

并集成员反序列化为对象的列表

另请参阅:

TypeReference

zUnionObject

<V> Set<V> zUnionObject(byte[][] keys,
                        Aggregate aggregate,
                        double[] weights,
                        com.buession.core.serializer.type.TypeReference<V> type)

计算给定的一个或多个有序集的并集，并反序列化为 type 指定的对象

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

类型参数:

V - 值类型

参数:

keys - 一个或多个 Key

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

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

type - 值类型引用

返回:

并集成员反序列化为对象的列表

另请参阅:

TypeReference