JedisCommands接口详解

朱雀 2022-04-13 07:47 413阅读 0赞

文章出处：https://blog.csdn.net/hu961691590/article/details/78549270

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
* Common interface for sharded and non-sharded Jedis
*/
public interface JedisCommands { 

  1. /\*\*  
  2.  \* 存储数据到缓存中，若key已存在则覆盖 value的长度不能超过1073741824 bytes (1 GB)  
  3.  \*  
  4.  \* @param key  
  5.  \* @param value  
  6.  \* @return  
  7.  \*/  
  8. String set(String key, String value);  
  11. /\*\*  
  12.  \* 存储数据到缓存中，并制定过期时间和当Key存在时是否覆盖。  
  13.  \*  
  14.  \* @param key  
  15.  \* @param value  
  16.  \* @param nxxx   
  17.  \*            nxxx的值只能取NX或者XX，如果取NX，则只有当key不存在是才进行set，如果取XX，则只有当key已经存在时才进行set  
  18.  \*   
  19.  \* @param expx expx的值只能取EX或者PX，代表数据过期时间的单位，EX代表秒，PX代表毫秒。  
  20.  \* @param time 过期时间，单位是expx所代表的单位。  
  21.  \* @return  
  22.  \*/  
  23. String set(String key, String value, String nxxx, String expx, long time);  
  26. /\*\*  
  27.  \* 从缓存中根据key取得其String类型的值，如果key不存在则返回null，如果key存在但value不是string类型的，  
  28.  \* 则返回一个error。这个方法只能从缓存中取得value为string类型的值。  
  29.  \*  
  30.  \* @param key  
  31.  \* @return  
  32.  \*/  
  33. String get(String key);  
  36. /\*\*  
  37.  \* 检查某个key是否在缓存中存在，如果存在返回true，否则返回false；需要注意的是，即使该key所对应的value是一个空字符串，  
  38.  \* 也依然会返回true。  
  39.  \*  
  40.  \* @param key  
  41.  \* @return  
  42.  \*/  
  43. Boolean exists(String key);  
  46. /\*\*  
  47.  \*   
  48.  \* 如果一个key设置了过期时间，则取消其过期时间，使其永久存在。  
  49.  \*  
  50.  \* @param key  
  51.  \* @return 返回1或者0,1代表取消过期时间成功，0代表不成功(只有当key不存在时这种情况才会发生)  
  52.  \*/  
  53. Long persist(String key);  
  56. /\*\*  
  57.  \* 返回某个key所存储的数据类型，返回的数据类型有可能是"none", "string", "list", "set", "zset",  
  58.  \* "hash". "none"代表key不存在。  
  59.  \*  
  60.  \* @param key  
  61.  \* @return  
  62.  \*/  
  63. String type(String key);  
  66. /\*\*  
  67.  \* 为key设置一个特定的过期时间，单位为秒。过期时间一到，redis将会从缓存中删除掉该key。  
  68.  \* 即使是有过期时间的key，redis也会在持久化时将其写到硬盘中，并把相对过期时间改为绝对的Unix过期时间。  
  69.  \* 在一个有设置过期时间的key上重复设置过期时间将会覆盖原先设置的过期时间。  
  70.  \*  
  71.  \* @param key  
  72.  \* @param seconds  
  73.  \* @return 返回1表示成功设置过期时间，返回0表示key不存在。  
  74.  \*/  
  75. Long expire(String key, int seconds);  
  78. /\*\*  
  79.  \* 机制同\{@link expire\}一样，只是时间单位改为毫秒。  
  80.  \*  
  81.  \* @param key  
  82.  \* @param milliseconds  
  83.  \* @return 返回值同 \{@link expire\}一样。  
  84.  \*/  
  85. Long pexpire(String key, long milliseconds);  
  88. /\*\*  
  89.  \* 与\{@link expire\}不一样，expireAt设置的时间不是能存活多久，而是固定的UNIX时间（从1970年开始算起），单位为秒。  
  90.  \*  
  91.  \* @param key  
  92.  \* @param unixTime  
  93.  \* @return  
  94.  \*/  
  95. Long expireAt(String key, long unixTime);  
  98. /\*\*  
  99.  \* 同\{@link expireAt\}机制相同，但单位为毫秒。  
  100.  \*  
  101.  \* @param key  
  102.  \* @param millisecondsTimestamp  
  103.  \* @return  
  104.  \*/  
  105. Long pexpireAt(String key, long millisecondsTimestamp);  
  108. /\*\*  
  109.  \* 返回一个key还能活多久，单位为秒  
  110.  \*  
  111.  \* @param key  
  112.  \* @return 如果该key本来并没有设置过期时间，则返回-1，如果该key不存在，则返回-2  
  113.  \*/  
  114. Long ttl(String key);  
  117. /\*\*  
  118.  \* 设置或者清除指定key的value上的某个位置的比特位，如果该key原先不存在，则新创建一个key，其value将会自动分配内存，  
  119.  \* 直到可以放下指定位置的bit值。  
  120.  \*   
  121.  \* @param key  
  122.  \* @param offset  
  123.  \* @param value true代表1，false代表0  
  124.  \* @return 返回原来位置的bit值是否是1，如果是1，则返回true，否则返回false。  
  125.  \*/  
  126. Boolean setbit(String key, long offset, boolean value);  
  129. /\*\*  
  130.  \* 设置或者清除指定key的value上的某个位置的比特位，如果该key原先不存在，则新创建一个key，其value将会自动分配内存，  
  131.  \* 直到可以放下指定位置的bit值。  
  132.  \*  
  133.  \* @param key  
  134.  \* @param offset  
  135.  \* @param value 只能是"1"或者"0"  
  136.  \* @return 返回原来位置的bit值是否是1，如果是1，则返回true，否则返回false。  
  137.  \*/  
  138. Boolean setbit(String key, long offset, String value);  
  141. /\*\*  
  142.  \* 取得偏移量为offset的bit值。  
  143.  \*  
  144.  \* @param key  
  145.  \* @param offset  
  146.  \* @return true代表1，false代表0  
  147.  \*/  
  148. Boolean getbit(String key, long offset);  
  151. /\*\*  
  152.  \* 这个命令的作用是覆盖key对应的string的一部分，从指定的offset处开始，覆盖value的长度。  
  153.  \* 如果offset比当前key对应string还要长，  
  154.  \* 那这个string后面就补0以达到offset。不存在的keys被认为是空字符串，所以这个命令可以确保key有一个足够大的字符串  
  155.  \* 能在offset处设置value。  
  156.  \*  
  157.  \* @param key  
  158.  \* @param offset  
  159.  \* @param value  
  160.  \* @return 该命令修改后的字符串长度  
  161.  \*/  
  162. Long setrange(String key, long offset, String value);  
  165. /\*\*  
  166.  \* 获得start - end之间的子字符串，若偏移量为负数，代表从末尾开始计算，例如-1代表倒数第一个，-2代表倒数第二个  
  167.  \*  
  168.  \* @param key  
  169.  \* @param startOffset  
  170.  \* @param endOffset  
  171.  \* @return  
  172.  \*/  
  173. String getrange(String key, long startOffset, long endOffset);  
  176. /\*\*  
  177.  \* 自动将key对应到value并且返回原来key对应的value。如果key存在但是对应的value不是字符串，就返回错误。  
  178.  \*   
  179.  \* @param key  
  180.  \* @param value  
  181.  \* @return  
  182.  \*/  
  183. String getSet(String key, String value);  
  186. /\*\*  
  187.  \* 参考 \{@link set(String key, String value, String nxxx, String expx, long  
  188.  \* time)\}  
  189.  \*  
  190.  \* @param key  
  191.  \* @param value  
  192.  \* @return  
  193.  \*/  
  194. Long setnx(String key, String value);  
  197. /\*\*  
  198.  \* 参考 \{@link set(String key, String value, String nxxx, String expx, long  
  199.  \* time)\}  
  200.  \*  
  201.  \* @param key  
  202.  \* @param seconds  
  203.  \* @param value  
  204.  \* @return  
  205.  \*/  
  206. String setex(String key, int seconds, String value);  
  209. /\*\*  
  210.  \* 将指定key的值减少某个值  
  211.  \*  
  212.  \* @param key  
  213.  \* @param integer  
  214.  \* @return 返回减少后的新值  
  215.  \*/  
  216. Long decrBy(String key, long integer);  
  219. /\*\*  
  220.  \* 将指定Key的值减少1  
  221.  \*  
  222.  \* @param key  
  223.  \* @return 返回减少后的新值  
  224.  \*/  
  225. Long decr(String key);  
  228. /\*\*  
  229.  \* 将指定的key的值增加指定的值  
  230.  \*  
  231.  \* @param key  
  232.  \* @param integer  
  233.  \* @return 返回增加后的新值  
  234.  \*/  
  235. Long incrBy(String key, long integer);  
  238. /\*\*  
  239.  \* 将指定的key的值增加指定的值(浮点数)  
  240.  \*  
  241.  \* @param key  
  242.  \* @param value  
  243.  \* @return 返回增加后的新值  
  244.  \*/  
  245. Double incrByFloat(String key, double value);  
  248. /\*\*  
  249.  \* 将指定的key的值增加1  
  250.  \*  
  251.  \* @param key  
  252.  \* @return 返回增加后的新值  
  253.  \*/  
  254. Long incr(String key);  
  257. /\*\*  
  258.  \* 若key存在，将value追加到原有字符串的末尾。若key不存在，则创建一个新的空字符串。  
  259.  \*  
  260.  \* @param key  
  261.  \* @param value  
  262.  \* @return 返回字符串的总长度  
  263.  \*/  
  264. Long append(String key, String value);  
  267. /\*\*  
  268.  \* 返回start - end 之间的子字符串(start 和 end处的字符也包括在内)  
  269.  \*  
  270.  \* @param key  
  271.  \* @param start  
  272.  \* @param end  
  273.  \* @return 返回子字符串  
  274.  \*/  
  275. String substr(String key, int start, int end);  
  278. /\*\*  
  279.  \* 设置hash表里field字段的值为value。如果key不存在，则创建一个新的hash表  
  280.  \*   
  281.  \* @param key  
  282.  \* @param field  
  283.  \* @param value  
  284.  \* @return 如果该字段已经存在，那么将会更新该字段的值，返回0.如果字段不存在，则新创建一个并且返回1.  
  285.  \*/  
  286. Long hset(String key, String field, String value);  
  289. /\*\*  
  290.  \* 如果该key对应的值是一个Hash表，则返回对应字段的值。 如果不存在该字段，或者key不存在，则返回一个"nil"值。  
  291.  \*  
  292.  \* @param key  
  293.  \* @param field  
  294.  \* @return  
  295.  \*/  
  296. String hget(String key, String field);  
  299. /\*\*  
  300.  \* 当字段不存在时，才进行set。  
  301.  \*  
  302.  \* @param key  
  303.  \* @param field  
  304.  \* @param value  
  305.  \* @return 如果该字段已经存在，则返回0.若字段不存在，则创建后set，返回1.  
  306.  \*/  
  307. Long hsetnx(String key, String field, String value);  
  310. /\*\*  
  311.  \* 设置多个字段和值，如果字段存在，则覆盖。  
  312.  \*  
  313.  \* @param key  
  314.  \* @param hash  
  315.  \* @return 设置成功返回OK，设置不成功则返回EXCEPTION  
  316.  \*/  
  317. String hmset(String key, Map<String, String> hash);  
  320. /\*\*  
  321.  \* 在hash中获取多个字段的值，若字段不存在，则其值为nil。  
  322.  \*  
  323.  \* @param key  
  324.  \* @param fields  
  325.  \* @return 按顺序返回多个字段的值。  
  326.  \*/  
  327. List<String> hmget(String key, String... fields);  
  330. /\*\*  
  331.  \* 对hash中指定字段的值增加指定的值  
  332.  \*  
  333.  \* @param key  
  334.  \* @param field  
  335.  \* @param value  
  336.  \* @return 返回增加后的新值  
  337.  \*/  
  338. Long hincrBy(String key, String field, long value);  
  341. /\*\*  
  342.  \* 判断hash中指定字段是否存在  
  343.  \*  
  344.  \* @param key  
  345.  \* @param field  
  346.  \* @return 若存在返回1，若不存在返回0  
  347.  \*/  
  348. Boolean hexists(String key, String field);  
  351. /\*\*  
  352.  \* 删除hash中指定字段  
  353.  \*  
  354.  \* @param key  
  355.  \* @param field  
  356.  \* @return 删除成功返回1， 删除不成功返回0  
  357.  \*/  
  358. Long hdel(String key, String... field);  
  361. /\*\*  
  362.  \* 返回 key 指定的哈希集包含的字段的数量  
  363.  \*  
  364.  \* @param key  
  365.  \* @return 哈希集中字段的数量，当 key 指定的哈希集不存在时返回 0  
  366.  \*/  
  367. Long hlen(String key);  
  370. /\*\*  
  371.  \* 返回 key 指定的哈希集中所有字段的名字。  
  372.  \*  
  373.  \* @param key  
  374.  \* @return 哈希集中的字段列表，当 key 指定的哈希集不存在时返回空列表。  
  375.  \*/  
  376. Set<String> hkeys(String key);  
  379. /\*\*  
  380.  \* 返回 key 指定的哈希集中所有字段的值。  
  381.  \*  
  382.  \* @param key  
  383.  \* @return 哈希集中的值的列表，当 key 指定的哈希集不存在时返回空列表。  
  384.  \*/  
  385. List<String> hvals(String key);  
  388. /\*\*  
  389.  \* 返回 key 指定的哈希集中所有的字段和值  
  390.  \*  
  391.  \* @param key  
  392.  \* @return 返回 key 指定的哈希集中所有的字段和值,若key不存在返回空map。  
  393.  \*/  
  394. Map<String, String> hgetAll(String key);  
  397. /\*\*  
  398.  \* 向存于 key 的列表的尾部插入所有指定的值。如果 key 不存在，那么会创建一个空的列表然后再进行 push 操作。 当 key  
  399.  \* 保存的不是一个列表，那么会返回一个错误。  
  400.  \*   
  401.  \* 可以使用一个命令把多个元素打入队列，只需要在命令后面指定多个参数。元素是从左到右一个接一个从列表尾部插入。 比如命令 RPUSH mylist a  
  402.  \* b c 会返回一个列表，其第一个元素是 a ，第二个元素是 b ，第三个元素是 c。  
  403.  \*  
  404.  \* @param key  
  405.  \* @param string  
  406.  \* @return 在 push 操作后的列表长度。  
  407.  \*/  
  408. Long rpush(String key, String... string);  
  411. /\*\*  
  412.  \* 将所有指定的值插入到存于 key 的列表的头部。如果 key 不存在，那么在进行 push 操作前会创建一个空列表。 如果 key  
  413.  \* 对应的值不是一个 list 的话，那么会返回一个错误。  
  414.  \*   
  415.  \* 可以使用一个命令把多个元素 push 进入列表，只需在命令末尾加上多个指定的参数。元素是从最左端的到最右端的、一个接一个被插入到 list  
  416.  \* 的头部。 所以对于这个命令例子 LPUSH mylist a b c，返回的列表是 c 为第一个元素， b 为第二个元素， a 为第三个元素。  
  417.  \*  
  418.  \* @param key  
  419.  \* @param string  
  420.  \* @return 在 push 操作后的列表长度。  
  421.  \*/  
  422. Long lpush(String key, String... string);  
  425. /\*\*  
  426.  \* 返回存储在 key 里的list的长度。 如果 key 不存在，那么就被看作是空list，并且返回长度为 0。 当存储在 key  
  427.  \* 里的值不是一个list的话，会返回error。  
  428.  \*  
  429.  \* @param key  
  430.  \* @return key对应的list的长度。  
  431.  \*/  
  432. Long llen(String key);  
  435. /\*\*  
  436.  \* 返回存储在 key 的列表里指定范围内的元素。 start 和 end  
  437.  \* 偏移量都是基于0的下标，即list的第一个元素下标是0（list的表头），第二个元素下标是1，以此类推。  
  438.  \*   
  439.  \* 偏移量也可以是负数，表示偏移量是从list尾部开始计数。 例如， -1 表示列表的最后一个元素，-2 是倒数第二个，以此类推。  
  440.  \*  
  441.  \* @param key  
  442.  \* @param start  
  443.  \* @param end  
  444.  \* @return 指定范围里的列表元素。  
  445.  \*/  
  446. List<String> lrange(String key, long start, long end);  
  449. /\*\*  
  450.  \* 修剪(trim)一个已存在的 list，这样 list 就会只包含指定范围的指定元素。start 和 stop 都是由0开始计数的， 这里的 0  
  451.  \* 是列表里的第一个元素（表头），1 是第二个元素，以此类推。  
  452.  \*  
  453.  \* @param key  
  454.  \* @param start  
  455.  \* @param end  
  456.  \* @return  
  457.  \*/  
  458. String ltrim(String key, long start, long end);  
  461. /\*\*  
  462.  \* 返回列表里的元素的索引 index 存储在 key 里面。 下标是从0开始索引的，所以 0 是表示第一个元素， 1 表示第二个元素，并以此类推。  
  463.  \* 负数索引用于指定从列表尾部开始索引的元素。在这种方法下，-1 表示最后一个元素，-2 表示倒数第二个元素，并以此往前推。  
  464.  \*   
  465.  \* 当 key 位置的值不是一个列表的时候，会返回一个error。  
  466.  \*  
  467.  \* @param key  
  468.  \* @param index  
  469.  \* @return 请求的对应元素，或者当 index 超过范围的时候返回 nil。  
  470.  \*/  
  471. String lindex(String key, long index);  
  474. /\*\*  
  475.  \* 设置 index 位置的list元素的值为 value。  
  476.  \*   
  477.  \* 当index超出范围时会返回一个error。  
  478.  \*  
  479.  \* @param key  
  480.  \* @param index  
  481.  \* @param value  
  482.  \* @return 状态恢复  
  483.  \*/  
  484. String lset(String key, long index, String value);  
  487. /\*\*  
  488.  \* 从存于 key 的列表里移除前 count 次出现的值为 value 的元素。 这个 count 参数通过下面几种方式影响这个操作：  
  489.  \*   
  490.  \* count > 0: 从头往尾移除值为 value 的元素。 count < 0: 从尾往头移除值为 value 的元素。 count = 0:  
  491.  \* 移除所有值为 value 的元素。  
  492.  \*   
  493.  \* 比如， LREM list -2 "hello" 会从存于 list 的列表里移除最后两个出现的 "hello"。  
  494.  \*   
  495.  \* 需要注意的是，如果list里没有存在key就会被当作空list处理，所以当 key 不存在的时候，这个命令会返回 0。  
  496.  \*  
  497.  \* @param key  
  498.  \* @param count  
  499.  \* @param value  
  500.  \* @return 返回删除的个数  
  501.  \*/  
  502. Long lrem(String key, long count, String value);  
  505. /\*\*  
  506.  \* 移除并且返回 key 对应的 list 的第一个元素。  
  507.  \*  
  508.  \* @param key  
  509.  \* @return 返回第一个元素的值，或者当 key 不存在时返回 nil。  
  510.  \*/  
  511. String lpop(String key);  
  514. /\*\*  
  515.  \* 移除并返回存于 key 的 list 的最后一个元素。  
  516.  \*  
  517.  \* @param key  
  518.  \* @return 最后一个元素的值，或者当 key 不存在的时候返回 nil。  
  519.  \*/  
  520. String rpop(String key);  
  523. /\*\*  
  524.  \* 添加一个或多个指定的member元素到集合的 key中.指定的一个或者多个元素member 如果已经在集合key中存在则忽略.如果集合key  
  525.  \* 不存在，则新建集合key,并添加member元素到集合key中.  
  526.  \*   
  527.  \* 如果key 的类型不是集合则返回错误.  
  528.  \*  
  529.  \* @param key  
  530.  \* @param member  
  531.  \* @return 返回新成功添加到集合里元素的数量，不包括已经存在于集合中的元素.  
  532.  \*/  
  533. Long sadd(String key, String... member);  
  536. /\*\*  
  537.  \* 返回key集合所有的元素.  
  538.  \*   
  539.  \* 该命令的作用与使用一个参数的SINTER 命令作用相同.  
  540.  \*  
  541.  \* @param key  
  542.  \* @return 集合中的所有元素.  
  543.  \*/  
  544. Set<String> smembers(String key);  
  547. /\*\*  
  548.  \* 在key集合中移除指定的元素. 如果指定的元素不是key集合中的元素则忽略 如果key集合不存在则被视为一个空的集合，该命令返回0.  
  549.  \*   
  550.  \* 如果key的类型不是一个集合,则返回错误.  
  551.  \*  
  552.  \* @param key  
  553.  \* @param member  
  554.  \* @return 从集合中移除元素的个数，不包括不存在的成员.  
  555.  \*/  
  556. Long srem(String key, String... member);  
  559. /\*\*  
  560.  \* 移除并返回一个集合中的随机元素  
  561.  \*   
  562.  \* 该命令与 SRANDMEMBER相似,不同的是srandmember命令返回一个随机元素但是不移除.  
  563.  \*  
  564.  \* @param key  
  565.  \* @return 被移除的元素, 当key不存在的时候返回 nil .  
  566.  \*/  
  567. String spop(String key);  
  570. /\*\*  
  571.  \* 移除并返回多个集合中的随机元素  
  572.  \*   
  573.  \* @param key  
  574.  \* @param count  
  575.  \* @return 被移除的元素, 当key不存在的时候值为 nil .  
  576.  \*/  
  577. Set<String> spop(String key, long count);  
  580. /\*\*  
  581.  \* 返回集合存储的key的基数 (集合元素的数量).  
  582.  \*  
  583.  \* @param key  
  584.  \* @return 集合的基数(元素的数量),如果key不存在,则返回 0.  
  585.  \*/  
  586. Long scard(String key);  
  589. /\*\*  
  590.  \* 返回成员 member 是否是存储的集合 key的成员.  
  591.  \*  
  592.  \* @param key  
  593.  \* @param member  
  594.  \* @return 如果member元素是集合key的成员，则返回1.如果member元素不是key的成员，或者集合key不存在，则返回0  
  595.  \*/  
  596. Boolean sismember(String key, String member);  
  599. /\*\*  
  600.  \* 仅提供key参数,那么随机返回key集合中的一个元素.该命令作用类似于SPOP命令, 不同的是SPOP命令会将被选择的随机元素从集合中移除,  
  601.  \* 而SRANDMEMBER仅仅是返回该随记元素,而不做任何操作.  
  602.  \*  
  603.  \* @param key  
  604.  \* @return 返回随机的元素,如果key不存在则返回nil  
  605.  \*/  
  606. String srandmember(String key);  
  609. /\*\*  
  610.  \* 如果count是整数且小于元素的个数，返回含有 count  
  611.  \* 个不同的元素的数组,如果count是个整数且大于集合中元素的个数时,仅返回整个集合的所有元素  
  612.  \* ,当count是负数,则会返回一个包含count的绝对值的个数元素的数组  
  613.  \* ，如果count的绝对值大于元素的个数,则返回的结果集里会出现一个元素出现多次的情况.  
  614.  \*  
  615.  \* @param key  
  616.  \* @param count  
  617.  \* @return 返回一个随机的元素数组,如果key不存在则返回一个空的数组.  
  618.  \*/  
  619. List<String> srandmember(String key, int count);  
  622. /\*\*  
  623.  \* 返回key的string类型value的长度。如果key对应的非string类型，就返回错误。  
  624.  \*  
  625.  \* @param key  
  626.  \* @return key对应的字符串value的长度，或者0（key不存在）  
  627.  \*/  
  628. Long strlen(String key);  
  631. /\*\*  
  632.  \* 该命令添加指定的成员到key对应的有序集合中，每个成员都有一个分数。你可以指定多个分数/成员组合。如果一个指定的成员已经在对应的有序集合中了，  
  633.  \* 那么其分数就会被更新成最新的  
  634.  \* ，并且该成员会重新调整到正确的位置，以确保集合有序。如果key不存在，就会创建一个含有这些成员的有序集合，就好像往一个空的集合中添加一样  
  635.  \* 。如果key存在，但是它并不是一个有序集合，那么就返回一个错误。  
  636.  \*   
  637.  \* 分数的值必须是一个表示数字的字符串，并且可以是double类型的浮点数。  
  638.  \*  
  639.  \* @param key  
  640.  \* @param score  
  641.  \* @param member  
  642.  \* @return 返回添加到有序集合中元素的个数，不包括那种已经存在只是更新分数的元素。  
  643.  \*/  
  644. Long zadd(String key, double score, String member);  
  647. /\*\*  
  648.  \* 该命令添加指定的成员到key对应的有序集合中，每个成员都有一个分数。你可以指定多个分数/成员组合。如果一个指定的成员已经在对应的有序集合中了，  
  649.  \* 那么其分数就会被更新成最新的  
  650.  \* ，并且该成员会重新调整到正确的位置，以确保集合有序。如果key不存在，就会创建一个含有这些成员的有序集合，就好像往一个空的集合中添加一样  
  651.  \* 。如果key存在，但是它并不是一个有序集合，那么就返回一个错误。  
  652.  \*   
  653.  \* 分数的值必须是一个表示数字的字符串，并且可以是double类型的浮点数。  
  654.  \*  
  655.  \* @param key  
  656.  \* @param scoreMembers  
  657.  \* @return 返回添加到有序集合中元素的个数，不包括那种已经存在只是更新分数的元素。  
  658.  \*/  
  659. Long zadd(String key, Map<String, Double> scoreMembers);  
  662. /\*\*  
  663.  \* 返回有序集key中，指定区间内的成员。其中成员按score值递增(从小到大)来排序。具有相同score值的成员按字典序来排列。  
  664.  \*   
  665.  \* 如果你需要成员按score值递减(score相等时按字典序递减)来排列，请使用ZREVRANGE命令。  
  666.  \* 下标参数start和stop都以0为底，也就是说，以0表示有序集第一个成员，以1表示有序集第二个成员，以此类推。  
  667.  \* 你也可以使用负数下标，以-1表示最后一个成员，-2表示倒数第二个成员，以此类推。  
  668.  \*   
  669.  \* 超出范围的下标并不会引起错误。如果start的值比有序集的最大下标还要大，或是start >  
  670.  \* stop时，ZRANGE命令只是简单地返回一个空列表。  
  671.  \* 另一方面，假如stop参数的值比有序集的最大下标还要大，那么Redis将stop当作最大下标来处理。  
  672.  \*  
  673.  \* @param key  
  674.  \* @param start  
  675.  \* @param end  
  676.  \* @return 指定范围的元素列表  
  677.  \*/  
  678. Set<String> zrange(String key, long start, long end);  
  681. /\*\*  
  682.  \* 从集合中删除指定member元素，当key存在，但是其不是有序集合类型，就返回一个错误。  
  683.  \*  
  684.  \* @param key  
  685.  \* @param member  
  686.  \* @return 返回的是从有序集合中删除的成员个数，不包括不存在的成员。  
  687.  \*/  
  688. Long zrem(String key, String... member);  
  691. /\*\*  
  692.  \* 为有序集key的成员member的score值加上增量increment。如果key中不存在member，就在key中添加一个member，  
  693.  \* score是increment（就好像它之前的score是0.0）。如果key不存在，就创建一个只含有指定member成员的有序集合。  
  694.  \*   
  695.  \* 当key不是有序集类型时，返回一个错误。  
  696.  \*   
  697.  \* score值必须整数值或双精度浮点数。也有可能给一个负数来减少score的值。  
  698.  \*  
  699.  \* @param key  
  700.  \* @param score  
  701.  \* @param member  
  702.  \* @return member成员的新score值.  
  703.  \*/  
  704. Double zincrby(String key, double score, String member);  
  707. /\*\*  
  708.  \* 返回有序集key中成员member的排名。其中有序集成员按score值递增(从小到大)顺序排列。排名以0为底，也就是说，  
  709.  \* score值最小的成员排名为0。  
  710.  \*   
  711.  \* 使用ZREVRANK命令可以获得成员按score值递减(从大到小)排列的排名。  
  712.  \*  
  713.  \* @param key  
  714.  \* @param member  
  715.  \* @return 如果member是有序集key的成员，返回member的排名的整数。 如果member不是有序集key的成员，返回 nil。  
  716.  \*/  
  717. Long zrank(String key, String member);  
  720. /\*\*  
  721.  \* 返回有序集key中成员member的排名，其中有序集成员按score值从大到小排列。排名以0为底，也就是说，score值最大的成员排名为0。  
  722.  \*   
  723.  \* 使用ZRANK命令可以获得成员按score值递增(从小到大)排列的排名。  
  724.  \*  
  725.  \* @param key  
  726.  \* @param member  
  727.  \* @return 如果member是有序集key的成员，返回member的排名。整型数字。 如果member不是有序集key的成员，返回Bulk  
  728.  \*         reply: nil.  
  729.  \*/  
  730. Long zrevrank(String key, String member);  
  733. /\*\*  
  734.  \* 返回有序集key中，指定区间内的成员。其中成员的位置按score值递减(从大到小)来排列。具有相同score值的成员按字典序的反序排列。  
  735.  \* 除了成员按score值递减的次序排列这一点外，ZREVRANGE命令的其他方面和ZRANGE命令一样。  
  736.  \*  
  737.  \* @param key  
  738.  \* @param start  
  739.  \* @param end  
  740.  \* @return 指定范围的元素列表(可选是否含有分数)。  
  741.  \*/  
  742. Set<String> zrevrange(String key, long start, long end);  
  745. /\*\*  
  746.  \* 返回有序集key中，指定区间内的成员。其中成员按score值递增(从小到大)来排序。具有相同score值的成员按字典序来排列。  
  747.  \*   
  748.  \* 如果你需要成员按score值递减(score相等时按字典序递减)来排列，请使用ZREVRANGE命令。  
  749.  \* 下标参数start和stop都以0为底，也就是说，以0表示有序集第一个成员，以1表示有序集第二个成员，以此类推。  
  750.  \* 你也可以使用负数下标，以-1表示最后一个成员，-2表示倒数第二个成员，以此类推。  
  751.  \*   
  752.  \* 超出范围的下标并不会引起错误。如果start的值比有序集的最大下标还要大，或是start >  
  753.  \* stop时，ZRANGE命令只是简单地返回一个空列表。  
  754.  \* 另一方面，假如stop参数的值比有序集的最大下标还要大，那么Redis将stop当作最大下标来处理。  
  755.  \*   
  756.  \* 使用WITHSCORES选项，来让成员和它的score值一并返回，返回列表以value1,score1, ...,  
  757.  \* valueN,scoreN的格式表示，而不是value1,...,valueN。客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。  
  758.  \*  
  759.  \* @param key  
  760.  \* @param start  
  761.  \* @param end  
  762.  \* @return 指定范围的元素列表(以元组集合的形式)。  
  763.  \*/  
  764. Set<Tuple> zrangeWithScores(String key, long start, long end);  
  767. /\*\*  
  768.  \* 返回有序集key中，指定区间内的成员。其中成员的位置按score值递减(从大到小)来排列。具有相同score值的成员按字典序的反序排列。  
  769.  \* 除了成员按score值递减的次序排列这一点外，ZREVRANGE命令的其他方面和ZRANGE命令一样。  
  770.  \*  
  771.  \* @param key  
  772.  \* @param start  
  773.  \* @param end  
  774.  \* @return 指定范围的元素列表(可选是否含有分数)。  
  775.  \*/  
  776. Set<Tuple> zrevrangeWithScores(String key, long start, long end);  
  779. /\*\*  
  780.  \* 返回key的有序集元素个数。  
  781.  \*  
  782.  \* @param key  
  783.  \* @return key存在的时候，返回有序集的元素个数，否则返回0。  
  784.  \*/  
  785. Long zcard(String key);  
  788. /\*\*  
  789.  \* 返回有序集key中，成员member的score值。  
  790.  \*   
  791.  \* 如果member元素不是有序集key的成员，或key不存在，返回nil。  
  792.  \*  
  793.  \* @param key  
  794.  \* @param member  
  795.  \* @return member成员的score值（double型浮点数）  
  796.  \*/  
  797. Double zscore(String key, String member);  
  800. /\*\*  
  801.  \* 对一个集合或者一个列表排序  
  802.  \*   
  803.  \* 对集合，有序集合，或者列表的value进行排序。默认情况下排序只对数字排序，双精度浮点数。  
  804.  \*   
  805.  \* @see \#sort(String, String)  
  806.  \* @see \#sort(String, SortingParams)  
  807.  \* @see \#sort(String, SortingParams, String)  
  808.  \* @param key  
  809.  \* @return 假设集合或列表包含的是数字元素，那么返回的将会是从小到大排列的一个列表。  
  810.  \*/  
  811. List<String> sort(String key);  
  814. /\*\*  
  815.  \* 根据指定参数来对列表或集合进行排序.  
  816.  \* <p>  
  817.  \* <b>examples:</b>  
  818.  \* <p>  
  819.  \* 一下是一些例子列表或者key-value:  
  820.  \*   
  821.  \* <pre>  
  822.  \* x = \[1, 2, 3\]  
  823.  \* y = \[a, b, c\]  
  824.  \*   
  825.  \* k1 = z  
  826.  \* k2 = y  
  827.  \* k3 = x  
  828.  \*   
  829.  \* w1 = 9  
  830.  \* w2 = 8  
  831.  \* w3 = 7  
  832.  \* </pre>  
  833.  \*   
  834.  \* 排序:  
  835.  \*   
  836.  \* <pre>  
  837.  \* sort(x) or sort(x, sp.asc())  
  838.  \* -> \[1, 2, 3\]  
  839.  \*   
  840.  \* sort(x, sp.desc())  
  841.  \* -> \[3, 2, 1\]  
  842.  \*   
  843.  \* sort(y)  
  844.  \* -> \[c, a, b\]  
  845.  \*   
  846.  \* sort(y, sp.alpha())  
  847.  \* -> \[a, b, c\]  
  848.  \*   
  849.  \* sort(y, sp.alpha().desc())  
  850.  \* -> \[c, b, a\]  
  851.  \* </pre>  
  852.  \*   
  853.  \* Limit (e.g. for Pagination):  
  854.  \*   
  855.  \* <pre>  
  856.  \* sort(x, sp.limit(0, 2))  
  857.  \* -> \[1, 2\]  
  858.  \*   
  859.  \* sort(y, sp.alpha().desc().limit(1, 2))  
  860.  \* -> \[b, a\]  
  861.  \* </pre>  
  862.  \*   
  863.  \* 使用外部键来排序:  
  864.  \*   
  865.  \* <pre>  
  866.  \* sort(x, sb.by(w\*))  
  867.  \* -> \[3, 2, 1\]  
  868.  \*   
  869.  \* sort(x, sb.by(w\*).desc())  
  870.  \* -> \[1, 2, 3\]  
  871.  \* </pre>  
  872.  \*   
  873.  \* Getting external keys:  
  874.  \*   
  875.  \* <pre>  
  876.  \* sort(x, sp.by(w\*).get(k\*))  
  877.  \* -> \[x, y, z\]  
  878.  \*   
  879.  \* sort(x, sp.by(w\*).get(\#).get(k\*))  
  880.  \* -> \[3, x, 2, y, 1, z\]  
  881.  \* </pre>  
  882.  \*   
  883.  \* @see \#sort(String)  
  884.  \* @see \#sort(String, SortingParams, String)  
  885.  \* @param key  
  886.  \* @param sortingParameters  
  887.  \* @return a list of sorted elements.  
  888.  \*/  
  889. List<String> sort(String key, SortingParams sortingParameters);  
  892. /\*\*  
  893.  \* 返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员。  
  894.  \*  
  895.  \* @param key  
  896.  \* @param min  
  897.  \* @param max  
  898.  \* @return 指定分数范围的元素个数。  
  899.  \*/  
  900. Long zcount(String key, double min, double max);  
  903. /\*\*  
  904.  \* 返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员。  
  905.  \*  
  906.  \* @param key  
  907.  \* @param min  
  908.  \* @param max  
  909.  \* @return 指定分数范围的元素个数。  
  910.  \*/  
  911. Long zcount(String key, String min, String max);  
  914. /\*\*  
  915.  \* 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。  
  916.  \* 具有相同分数的元素按字典序排列  
  917.  \*  
  918.  \* @param key  
  919.  \* @param min  
  920.  \* @param max  
  921.  \* @return 指定分数范围的元素列表  
  922.  \*/  
  923. Set<String> zrangeByScore(String key, double min, double max);  
  926. /\*\*  
  927.  \* 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。  
  928.  \* 具有相同分数的元素按字典序排列  
  929.  \*  
  930.  \* @param key  
  931.  \* @param min  
  932.  \* @param max  
  933.  \* @return 指定分数范围的元素列表  
  934.  \*/  
  935. Set<String> zrangeByScore(String key, String min, String max);  
  938. /\*\*  
  939.  \* 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。  
  940.  \* 具有相同分数的元素按字典序排列, 指定返回结果的数量及区间。  
  941.  \*  
  942.  \* @param key  
  943.  \* @param min  
  944.  \* @param max  
  945.  \* @param offset  
  946.  \* @param count  
  947.  \* @return 指定分数范围的元素列表  
  948.  \*/  
  949. Set<String> zrangeByScore(String key, double min, double max, int offset, int count);  
  952. /\*\*  
  953.  \* 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。  
  954.  \* 具有相同分数的元素按字典序排列, 指定返回结果的数量及区间。  
  955.  \*  
  956.  \* @param key  
  957.  \* @param min  
  958.  \* @param max  
  959.  \* @param offset  
  960.  \* @param count  
  961.  \* @return 指定分数范围的元素列表  
  962.  \*/  
  963. Set<String> zrangeByScore(String key, String min, String max, int offset, int count);  
  966. /\*\*  
  967.  \* 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。  
  968.  \* 具有相同分数的元素按字典序排列。返回元素和其分数，而不只是元素。  
  969.  \*  
  970.  \* @param key  
  971.  \* @param min  
  972.  \* @param max  
  973.  \* @return  
  974.  \*/  
  975. Set<Tuple> zrangeByScoreWithScores(String key, double min, double max);  
  978. /\*\*  
  979.  \* 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。  
  980.  \* 具有相同分数的元素按字典序排列, 指定返回结果的数量及区间。 返回元素和其分数，而不只是元素。  
  981.  \*  
  982.  \* @param key  
  983.  \* @param min  
  984.  \* @param max  
  985.  \* @param offset  
  986.  \* @param count  
  987.  \* @return  
  988.  \*/  
  989. Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset,  
  990.         int count);  
  993. /\*\*  
  994.  \* 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。  
  995.  \* 具有相同分数的元素按字典序排列。返回元素和其分数，而不只是元素。  
  996.  \*  
  997.  \* @param key  
  998.  \* @param min  
  999.  \* @param max  
  1000.  \* @return  
  1001.  \*/  
  1002. Set<Tuple> zrangeByScoreWithScores(String key, String min, String max);  
  1005. /\*\*  
  1006.  \* 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。  
  1007.  \* 具有相同分数的元素按字典序排列, 指定返回结果的数量及区间。 返回元素和其分数，而不只是元素。  
  1008.  \*  
  1009.  \* @param key  
  1010.  \* @param min  
  1011.  \* @param max  
  1012.  \* @param offset  
  1013.  \* @param count  
  1014.  \* @return  
  1015.  \*/  
  1016. Set<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset,  
  1017.         int count);  
  1020. /\*\*  
  1021.  \* 机制与zrangeByScore一样，只是返回结果为降序排序。  
  1022.  \*  
  1023.  \* @param key  
  1024.  \* @param max  
  1025.  \* @param min  
  1026.  \* @return  
  1027.  \*/  
  1028. Set<String> zrevrangeByScore(String key, double max, double min);  
  1031. /\*\*  
  1032.  \* 机制与zrangeByScore一样，只是返回结果为降序排序。  
  1033.  \*  
  1034.  \* @param key  
  1035.  \* @param max  
  1036.  \* @param min  
  1037.  \* @return  
  1038.  \*/  
  1039. Set<String> zrevrangeByScore(String key, String max, String min);  
  1042. /\*\*  
  1043.  \* 机制与zrangeByScore一样，只是返回结果为降序排序。  
  1044.  \*  
  1045.  \* @param key  
  1046.  \* @param max  
  1047.  \* @param min  
  1048.  \* @param offset  
  1049.  \* @param count  
  1050.  \* @return  
  1051.  \*/  
  1052. Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count);  
  1055. /\*\*  
  1056.  \* 机制与zrangeByScoreWithScores一样，只是返回结果为降序排序。  
  1057.  \*  
  1058.  \* @param key  
  1059.  \* @param max  
  1060.  \* @param min  
  1061.  \* @return  
  1062.  \*/  
  1063. Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min);  
  1066. /\*\*  
  1067.  \* 机制与zrangeByScore一样，只是返回结果为降序排序。  
  1068.  \*  
  1069.  \* @param key  
  1070.  \* @param max  
  1071.  \* @param min  
  1072.  \* @param offset  
  1073.  \* @param count  
  1074.  \* @return  
  1075.  \*/  
  1076. Set<String> zrevrangeByScore(String key, String max, String min, int offset, int count);  
  1079. /\*\*  
  1080.  \* 机制与zrangeByScoreWithScores一样，只是返回结果为降序排序。  
  1081.  \*  
  1082.  \* @param key  
  1083.  \* @param max  
  1084.  \* @param min  
  1085.  \* @return  
  1086.  \*/  
  1087. Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min);  
  1090. /\*\*  
  1091.  \* 机制与zrangeByScoreWithScores一样，只是返回结果为降序排序。  
  1092.  \*  
  1093.  \* @param key  
  1094.  \* @param max  
  1095.  \* @param min  
  1096.  \* @param offset  
  1097.  \* @param count  
  1098.  \* @return  
  1099.  \*/  
  1100. Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset,  
  1101.         int count);  
  1104. /\*\*  
  1105.  \* 机制与zrangeByScoreWithScores一样，只是返回结果为降序排序。  
  1106.  \*  
  1107.  \* @param key  
  1108.  \* @param max  
  1109.  \* @param min  
  1110.  \* @param offset  
  1111.  \* @param count  
  1112.  \* @return  
  1113.  \*/  
  1114. Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset,  
  1115.         int count);  
  1118. /\*\*  
  1119.  \* 移除有序集key中，指定排名(rank)区间内的所有成员。下标参数start和stop都以0为底，0处是分数最小的那个元素。这些索引也可是负数，  
  1120.  \* 表示位移从最高分处开始数。例如，-1是分数最高的元素，-2是分数第二高的，依次类推。  
  1121.  \*  
  1122.  \* @param key  
  1123.  \* @param start  
  1124.  \* @param end  
  1125.  \* @return 被移除成员的数量。  
  1126.  \*/  
  1127. Long zremrangeByRank(String key, long start, long end);  
  1130. /\*\*  
  1131.  \* 移除有序集key中，所有score值介于min和max之间(包括等于min或max)的成员。  
  1132.  \*   
  1133.  \* 自版本2.1.6开始，score值等于min或max的成员也可以不包括在内，语法请参见ZRANGEBYSCORE命令。  
  1134.  \*  
  1135.  \* @param key  
  1136.  \* @param start  
  1137.  \* @param end  
  1138.  \* @return 删除的元素的个数  
  1139.  \*/  
  1140. Long zremrangeByScore(String key, double start, double end);  
  1143. /\*\*  
  1144.  \* 移除有序集key中，所有score值介于min和max之间(包括等于min或max)的成员。  
  1145.  \*   
  1146.  \* 自版本2.1.6开始，score值等于min或max的成员也可以不包括在内，语法请参见ZRANGEBYSCORE命令。  
  1147.  \*  
  1148.  \* @param key  
  1149.  \* @param start  
  1150.  \* @param end  
  1151.  \* @return 删除的元素的个数  
  1152.  \*/  
  1153. Long zremrangeByScore(String key, String start, String end);  
  1156. /\*\*  
  1157.  \* 当插入到有序集合中的元素都具有相同的分数时，这个命令可以返回min和max指定范围内的元素的数量。  
  1158.  \*  
  1159.  \* @param key  
  1160.  \* @param min  
  1161.  \* @param max  
  1162.  \* @return  
  1163.  \*/  
  1164. Long zlexcount(final String key, final String min, final String max);  
  1167. /\*\*  
  1168.  \* 把 value 插入存于 key 的列表中在基准值 pivot 的前面或后面。  
  1169.  \*   
  1170.  \* 当 key 不存在时，这个list会被看作是空list，任何操作都不会发生。  
  1171.  \*   
  1172.  \* 当 key 存在，但保存的不是一个list的时候，会返回error。  
  1173.  \*  
  1174.  \* @param key  
  1175.  \* @param where  
  1176.  \* @param pivot 前或后  
  1177.  \* @param value  
  1178.  \* @return 在 insert 操作后的 list 长度。  
  1179.  \*/  
  1180. Long linsert(String key, Client.LIST\_POSITION where, String pivot, String value);  
  1183. /\*\*  
  1184.  \* 只有当 key 已经存在并且存着一个 list 的时候，在这个 key 下面的 list 的头部插入 value。 与 LPUSH 相反，当  
  1185.  \* key 不存在的时候不会进行任何操作。  
  1186.  \*  
  1187.  \* @param key  
  1188.  \* @param string  
  1189.  \* @return 在 push 操作后的 list 长度。  
  1190.  \*/  
  1191. Long lpushx(String key, String... string);  
  1194. /\*\*  
  1195.  \* 将值 value 插入到列表 key 的表尾, 当且仅当 key 存在并且是一个列表。 和 RPUSH 命令相反, 当 key  
  1196.  \* 不存在时，RPUSHX 命令什么也不做。  
  1197.  \*  
  1198.  \* @param key  
  1199.  \* @param string  
  1200.  \* @return 在Push操作后List的长度  
  1201.  \*/  
  1202. Long rpushx(String key, String... string);  
  1205. /\*\*  
  1206.  \* @deprecated unusable command, this will be removed in 3.0.0.  
  1207.  \*/  
  1208. @Deprecated  
  1209. List<String> blpop(String arg);  
  1212. /\*\*  
  1213.  \* BLPOP 是阻塞式列表的弹出原语。 它是命令 LPOP 的阻塞版本，这是因为当给定列表内没有任何元素可供弹出的时候， 连接将被 BLPOP  
  1214.  \* 命令阻塞。 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。 \{@link http  
  1215.  \* ://www.redis.cn/commands/blpop.html\}  
  1216.  \*   
  1217.  \* @param timeout  
  1218.  \* @param key  
  1219.  \* @return  
  1220.  \*/  
  1221. List<String> blpop(int timeout, String key);  
  1224. /\*\*  
  1225.  \* @deprecated unusable command, this will be removed in 3.0.0.  
  1226.  \*/  
  1227. @Deprecated  
  1228. List<String> brpop(String arg);  
  1231. /\*\*  
  1232.  \* BRPOP 是一个阻塞的列表弹出原语。 它是 RPOP 的阻塞版本，因为这个命令会在给定list无法弹出任何元素的时候阻塞连接。  
  1233.  \* 该命令会按照给出的 key 顺序查看 list，并在找到的第一个非空 list 的尾部弹出一个元素。  
  1234.  \*   
  1235.  \* 请在 BLPOP 文档 中查看该命令的准确语义，因为 BRPOP 和 BLPOP  
  1236.  \* 基本是完全一样的，除了它们一个是从尾部弹出元素，而另一个是从头部弹出元素。 \{@link http  
  1237.  \* ://www.redis.cn/commands/brpop.html\}  
  1238.  \*   
  1239.  \*   
  1240.  \* @param timeout  
  1241.  \* @param key  
  1242.  \* @return  
  1243.  \*/  
  1244. List<String> brpop(int timeout, String key);  
  1247. /\*\*  
  1248.  \* 删除一个Key,如果删除的key不存在，则直接忽略。  
  1249.  \*  
  1250.  \* @param key  
  1251.  \* @return 被删除的keys的数量  
  1252.  \*/  
  1253. Long del(String key);  
  1256. /\*\*  
  1257.  \* 回显  
  1258.  \*  
  1259.  \* @param string  
  1260.  \* @return 回显输入的字符串  
  1261.  \*/  
  1262. String echo(String string);  
  1265. /\*\*  
  1266.  \* 将当前数据库的 key 移动到给定的数据库 db 当中。  
  1267.  \*   
  1268.  \* 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。  
  1269.  \*   
  1270.  \* 因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。  
  1271.  \*  
  1272.  \* @param key  
  1273.  \* @param dbIndex  
  1274.  \* @return 移动成功返回 1 失败则返回 0  
  1275.  \*/  
  1276. Long move(String key, int dbIndex);  
  1279. /\*\*  
  1280.  \* 统计字符串的字节数  
  1281.  \*  
  1282.  \* @param key  
  1283.  \* @return 字节数  
  1284.  \*/  
  1285. Long bitcount(final String key);  
  1288. /\*\*  
  1289.  \* 统计字符串指定起始位置的字节数  
  1290.  \*  
  1291.  \* @param key  
  1292.  \* @param start  
  1293.  \* @param end  
  1294.  \* @return  
  1295.  \*/  
  1296. Long bitcount(final String key, long start, long end);  
  1299. /\*\*  
  1300.  \* 迭代hash里面的元素  
  1301.  \*  
  1302.  \* @param key  
  1303.  \* @param cursor  
  1304.  \* @return  
  1305.  \*/  
  1306. ScanResult<Map.Entry<String, String>> hscan(final String key, final String cursor);  
  1309. /\*\*  
  1310.  \* 迭代set里面的元素  
  1311.  \*  
  1312.  \* @param key  
  1313.  \* @param cursor  
  1314.  \* @return  
  1315.  \*/  
  1316. ScanResult<String> sscan(final String key, final String cursor);  
  1319. /\*\*  
  1320.  \* 迭代zset里面的元素  
  1321.  \*  
  1322.  \* @param key  
  1323.  \* @param cursor  
  1324.  \* @return  
  1325.  \*/  
  1326. ScanResult<Tuple> zscan(final String key, final String cursor);

}

发表评论

表情：
评论列表 （有 0 条评论，413人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java接口详解

    接口 接口的概念 在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。 > 电脑的USB口上，可以插：U盘，鼠标，键盘等所有符合USB协议的设

    向右看齐向右看齐/ 0 赞/ 226 阅读