启动redis
package com.yujie.jedis; import java.util.HashMap;
import java.util.Map;
import java.util.Set; import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple; public class TestJedis {
public static void main(String[] args) {
/*创建Jedis对象*/
Jedis jedis = new Jedis("192.168.1.100",6379);
/*测试连接*/
String ping = jedis.ping();
/*输出ping结果、PONG表示连接成功*/
System.out.println("输出ping结果、PONG表示连接成功:" + ping);
System.out.println(); /**************************key-k520*************************/
System.out.println("**************************key-k520*************************");
/*查询当前库的所有键*/
Set<String> keys = jedis.keys("*");
/*遍历输出所有键*/
System.out.println("遍历输出所有键:");
for(String key : keys) {
System.out.print(key + ",");
}
System.out.println();
/*判断某个键是否存在*/
System.out.println("判断某个键是否存在。k520【key】--jedis.exists====>"+jedis.exists("k520"));
/*查看键的类型*/
System.out.println("查看键的类型。k520【key】--jedis.type====>"+jedis.type("k520"));
/*删除某个键*/
System.out.println("删除某个键,1表示删除成功,0表示删除失败。k520【key】--jedis.del====>"+jedis.del("k520"));
/*为键值设置过期时间,单位秒*/
System.out.println("为键值设置过期时间,单位秒。k520-600【key-second】--jedis.expire====>"+jedis.expire("k520", 600));
/*查看还有多少秒过期,-1表示永不过期,-2表示已过期*/
System.out.println("查看还有多少秒过期,大于0的数表示剩余秒数,-1表示永不过期,-2表示已过期。k520【key】--jedis.ttl====>"+jedis.ttl("k520"));
/*查看当前数据库的key的数量*/
System.out.println("查看当前数据库的key的数量--jedis.dbSize====>"+jedis.dbSize());
/*清空当前库,注意慎重使用*/
/*System.out.println("清空当前库--jedis.flushDB====>"+jedis.flushDB());*/
/*通杀全部库,注意慎重使用*/
/*System.out.println("通杀全部库--jedis.flushAll====>"+jedis.flushAll());*/ /**************************String-k999-k520*************************/
System.out.println("**************************String-k999-k520*************************");
/*String是Redis最基本的类型,你可以理解成与Memcached一模一样的类型,一个key对应一个value。
String类型是二进制安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。
String类型是Redis最基本的数据类型,一个Redis中字符串value最多可以是512M。*/
/*查询对应键值*/
System.out.println("查询对应键值。k999【key】--jedis.get====>"+jedis.get("k999"));
/*添加键值对*/
System.out.println("添加键值对。k999-v999【key-value】--jedis.set====>"+jedis.set("k999", "v999"));
/*将给定的<value> 追加到原值的末尾*/
System.out.println("将给定的<value> 追加到原值的末尾,输出添加后值的长度。 k999-1【key-value】--jedis.append====>"+jedis.append("k999", "1"));
/*获得值的长度*/
System.out.println("获得值的长度。k999【key】--jedis.strlen====>"+jedis.strlen("k999"));
/*只有在 key 不存在时设置 key 的值*/
System.out.println("只有在 key不存在时设置 key的值,不存在时设置后返回1,存在时不能设置返回0。k520-520【key-value】--jedis.setnx====>"+jedis.setnx("k520", "520"));
/*将 key中储存的数字值增1,只能对数字值操作,如果为空,新增值为1*/
System.out.println("将 key中储存的数字值增1,只能对数字值操作,如果为空,新增值为1。k520【key】--jedis.incr====>"+jedis.incr("k520"));
/*将 key中储存的数字值减1,只能对数字值操作,如果为空,新增值为-1*/
System.out.println("将 key中储存的数字值减1,只能对数字值操作,如果为空,新增值为-1。k520【key】--jedis.decr====>"+jedis.decr("k520"));
/*将 key中储存的数字值增加。自定义步长。*/
System.out.println("将 key中储存的数字值增加。自定义步长。k520-100【key-num】--jedis.incrBy,显示增加后的值====>"+jedis.incrBy("k520", 100));
/*将 key中储存的数字值减少。自定义步长。*/
System.out.println("将 key中储存的数字值减少。自定义步长。k520-100【key-num】--jedis.decrBy,显示减少后的值====>"+jedis.decrBy("k520", 100));
/*同时设置一个或多个 key-value对*/
System.out.println("同时设置一个或多个key-value对。name-余杰,sex-男【key-value,key-value】--jedis.mset====>"+jedis.mset("name","余杰","sex","男"));
/*同时获取一个或多个 value*/
System.out.println("查询对应键值。name, sex【key,key】--jedis.mget====>"+jedis.mget("name","sex"));
/*同时设置一个或多个 key-value 对,当且仅当所有给定 key 都不存在。*/
System.out.println("同时设置一个或多个 key-value 对,当且仅当所有给定 key都不存在。"
+ "省-福建,市-福州【key-value,key-value】。不存在时设置后返回1,存在时不能设置返回0--jedis.msetnx====>"
+jedis.msetnx("省","福建","市","福州"));
/*获得值的范围,类似java中的substring*/
System.out.println("获得值的范围,类似java中的substring。从0开始计算。k520-0-1【键-开始(包括)-结尾(包括),key-0-1,表示获取前两位】--jedis.getrange====>"+jedis.getrange("k520", 0, 1));
/*用 <value>覆写<key> 所储存的字符串值,从<起始位置>开始。*/
System.out.println("用 <value>覆写<key> 所储存的字符串值,从<起始位置>开始。k520【从0开始计算,键-起始位置(包括)-值,key-0-99,表示替换前两位为99】--jedis.setrange====>"+jedis.setrange("k520", 0, "99"));
/*设置键值的同时,设置过期时间,单位秒。*/
System.out.println("设置键值的同时,设置过期时间,单位秒。k520【key-60-888,表示设置key的值为888,且60秒后过期】--jedis.setex====>"+jedis.setex("k520", 60, "888"));
/*查看还有多少秒过期,-1表示永不过期,-2表示已过期*/
System.out.println("查看还有多少秒过期,大于0的数表示剩余秒数,-1表示永不过期,-2表示已过期k520【key】--jedis.ttl====>"+jedis.ttl("k520"));
/*以新换旧,设置了新值同时获得旧值。*/
System.out.println("以新换旧,设置了新值同时获得旧值。k520【key-001,表示设置key的新值为001,且获取原来的值】--jedis.getSet====>"+jedis.getSet("k520", "001"));
System.out.println(); /**************************List-k2000-k3000*************************/
System.out.println("**************************List-k2000-k3000*************************");
/*单键多值
Redis 列表是简单的字符串列表,按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
它的底层实际是个双向链表,对两端的操作性能很高,通过索引下标的操作中间的节点性能会较差。*/
/*从左边插入一个或多个值。*/
System.out.println("从左边插入一个或多个值。返回插入后的值数量k2000【key-value-value-...】--jedis.lpush====>"+jedis.lpush("k2000","v1","v2"));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>"+jedis.lrange("k2000", 0, 10000));
/*从右边插入一个或多个值。*/
System.out.println("从右边插入一个或多个值。返回插入后的值数量k2000【key-value-value-...】--jedis.rpush====>"+jedis.rpush("k2000","v3","v4"));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>"+jedis.lrange("k2000", 0, 10000));
/*从左边吐出一个值。值在键在,值亡键亡。*/
System.out.println("从左边吐出一个值。值在键在,值亡键亡。k2000【key】--jedis.lpop====>"+jedis.lpop("k2000"));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>"+jedis.lrange("k2000", 0, 10000));
/*从右边吐出一个值。值在键在,值亡键亡。*/
System.out.println("从右边吐出一个值。值在键在,值亡键亡。k2000【key】--jedis.rpop====>"+jedis.rpop("k2000"));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>"+jedis.lrange("k2000", 0, 10000));
/*从左边插入一个或多个值。*/
System.out.println("从左边插入一个或多个值。返回插入后的值数量k3000【key-value-value-...】--jedis.lpush====>"+jedis.lpush("k3000","v3000","v3001"));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k3000【key-0-10000】--jedis.lrange====>"+jedis.lrange("k3000", 0, 10000));
/*从<key1>列表右边吐出一个值,插到<key2>列表左边。*/
System.out.println("从<key1>列表右边吐出一个值,插到<key2>列表左边。k2000【key1,key2】--jedis.rpoplpush====>"+jedis.rpoplpush("k2000", "k3000"));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>"+jedis.lrange("k2000", 0, 10000));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k3000【key-0-10000】--jedis.lrange====>"+jedis.lrange("k3000", 0, 10000));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k2000【key-0,获取第一个值】--jedis.lindex====>"+jedis.lindex("k2000", 0));
/*获得列表长度*/
System.out.println("获得列表长度k2000【key】--jedis.llen====>"+jedis.llen("k2000"));
/*获得列表长度*/
System.out.println("获得列表长度k3000【key】--jedis.llen====>"+jedis.llen("k3000"));
/*在<value>的前面插入<newvalue>*/
System.out.println("在<value>的前面插入<newvalue>k2000【key-LIST_POSITION.BEFORE-value-newvalue】--jedis.linsert====>"+jedis.linsert("k2000", LIST_POSITION.BEFORE, "v1", "v2333"));
/*在<value>的后面插入<newvalue>*/
System.out.println("在<value>的后面插入<newvalue>k2000【key-LIST_POSITION.AFTER-value-newvalue】--jedis.linsert====>"+jedis.linsert("k2000", LIST_POSITION.AFTER, "v1", "v2444"));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>"+jedis.lrange("k2000", 0, 10000));
/*从左边删除n个value(从左到右)*/
System.out.println("从左边删除n个value(从左到右)k2000【key-10000-value】--jedis.lrem====>"+jedis.lrem("k2000", 10000, "v1"));
/*按照索引下标获得元素(从左到右)*/
System.out.println("按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>"+jedis.lrange("k2000", 0, 10000));
/*删除某个键*/
System.out.println("删除某个键,1表示删除成功,0表示删除失败k2000【key】--jedis.del====>"+jedis.del("k2000"));
/*删除某个键*/
System.out.println("删除某个键,1表示删除成功,0表示删除失败k3000【key】--jedis.del====>"+jedis.del("k3000"));
System.out.println(); /**************************Set-k4000*************************/
System.out.println("**************************Set-k4000-k5000*************************");
/*Redis set对外提供的功能与list类似是一个列表的功能,
特殊之处在于set是可以自动排重的,当你需要存储一个列表数据,
又不希望出现重复数据时,set是一个很好的选择,
并且set提供了判断某个成员是否在一个set集合内的重要接口,这个也是list所不能提供的。*/
/*Redis的Set是string类型的无序集合。
它底层其实是一个value为null的hash表,所以添加,删除,查找的复杂度都是O(1)。*/
/*将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。*/
System.out.println("将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。k4000【key-value-value-...】--jedis.sadd====>"+jedis.sadd("k4000", "v4001", "v4002", "v4003"));
/*取出该集合的所有值。*/
System.out.println("取出该集合的所有值。k4000【key】--jedis.smembers====>"+jedis.smembers("k4000"));
/*判断集合<key>是否为含有该<value>值,有返回1,没有返回0*/
System.out.println("判断集合<key>是否为含有该<value>值,有返回true,没有返回false。k4000【key-value】--jedis.get====>"+jedis.sismember("k4000", "v4001"));
/*返回该集合的元素个数。*/
System.out.println("返回该集合的元素个数。k4000【key】--jedis.scard====>"+jedis.scard("k4000"));
/*删除集合中的某个元素。*/
System.out.println("删除集合中的某个元素。k4000【key-value-value-...】--jedis.srem====>"+jedis.srem("k4000", "v4001", "v4002"));
/*取出该集合的所有值。*/
System.out.println("取出该集合的所有值。k4000【key】--jedis.smembers====>"+jedis.smembers("k4000"));
/*将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。*/
System.out.println("将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。k4000【key-value-value-...】--jedis.sadd====>"+jedis.sadd("k4000", "v4001", "v4002"));
/*取出该集合的所有值。*/
System.out.println("取出该集合的所有值。k4000【key】--jedis.smembers====>"+jedis.smembers("k4000"));
/*随机从该集合中吐出一个值。*/
System.out.println("随机从该集合中吐出一个值。k4000【key】--jedis.spop====>"+jedis.spop("k4000"));
/*取出该集合的所有值。*/
System.out.println("取出该集合的所有值。k4000【key】--jedis.smembers====>"+jedis.smembers("k4000"));
/*随机从该集合中取出1个值。不会从集合中删除*/
System.out.println("随机从该集合中取出1个值。不会从集合中删除。k4000【key】--jedis.get====>"+jedis.srandmember("k4000"));
/*取出该集合的所有值。*/
System.out.println("取出该集合的所有值。k4000【key】--jedis.smembers====>"+jedis.smembers("k4000"));
/*随机从该集合中取出1个值。不会从集合中删除*/
System.out.println("随机从该集合中取出n个值。不会从集合中删除。k4000【key-num】--jedis.get====>"+jedis.srandmember("k4000", 2));
/*取出该集合的所有值。*/
System.out.println("取出该集合的所有值。k4000【key】--jedis.smembers====>"+jedis.smembers("k4000"));
/*删除某个键*/
System.out.println("删除某个键,1表示删除成功,0表示删除失败k4000【key】--jedis.del====>"+jedis.del("k4000"));
/*删除某个键*/
System.out.println("删除某个键,1表示删除成功,0表示删除失败k5000【key】--jedis.del====>"+jedis.del("k5000"));
/*将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。*/
System.out.println("将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。k4000【key-value-value-...】--jedis.sadd====>"+jedis.sadd("k4000", "v4001", "v5002", "v4003"));
/*将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。*/
System.out.println("将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。k5000【key-value-value-...】--jedis.sadd====>"+jedis.sadd("k5000", "v4001", "v5002", "v5003"));
/*取出该集合的所有值。*/
System.out.println("取出该集合的所有值。k4000【key】--jedis.smembers====>"+jedis.smembers("k4000"));
/*取出该集合的所有值。*/
System.out.println("取出该集合的所有值。k5000【key】--jedis.smembers====>"+jedis.smembers("k5000"));
/*返回两个集合的交集元素。*/
System.out.println("返回两个集合的交集元素。【key1-key2】--jedis.sinter====>"+jedis.sinter("k4000", "k5000"));
/*返回两个集合的并集元素。*/
System.out.println("返回两个集合的并集元素。【key1-key2】--jedis.sunion====>"+jedis.sunion("k4000", "k5000"));
/*返回两个集合的差集元素。*/
System.out.println("返回两个集合的差集元素。【key1-key2】--jedis.sdiff====>"+jedis.sdiff("k4000", "k5000"));
System.out.println(); /**************************hash-k6000*************************/
System.out.println("**************************hash-k6000*************************");
/*Redis hash 是一个键值对集合。
Redis hash是一个string类型的field和value的映射表,hash特别适合用于存储对象。
类似Java里面的Map<String,Object>*/
/*给<key>集合中的 <field>键赋值<value>*/
System.out.println("给<key>集合中的 <field>键赋值<value>。k6000-name-yujie【key-field-value】--jedis.hset====>"+jedis.hset("k6000", "name", "yujie"));
/*从<key1>集合<field> 取出 value*/
System.out.println("从<key1>集合<field> 取出 value。k6000-name【key-field】--jedis.hget====>"+jedis.hget("k6000", "name"));
/*参数Map*/
Map<String, String> hashmap = new HashMap<String, String>();
hashmap.put("age", "18");
hashmap.put("sex", "man");
/*批量设置hash的值*/
System.out.println("批量设置hash的值。k6000。age-18,sex-man【key-map】--jedis.hmset====>"+jedis.hmset("k6000", hashmap));
/*查看哈希表 key 中,给定域 field 是否存在。*/
System.out.println("查看哈希表 key 中,给定域 field 是否存在。k6000-name【key-field】--jedis.hexists====>"+jedis.hexists("k6000", "name"));
/*列出该hash集合的所有field*/
System.out.println("列出该hash集合的所有field。k6000【key】--jedis.hkeys====>"+jedis.hkeys("k6000"));
/*列出该hash集合的所有value*/
System.out.println("列出该hash集合的所有value。k6000【key】--jedis.hvals====>"+jedis.hvals("k6000"));
/*为哈希表 key 中的域 field 的值加上增量 increment*/
System.out.println("为哈希表 key 中的域 field 的值加上增量 increment。k6000-age -10【key-field-num】--jedis.hincrBy====>"+jedis.hincrBy("k6000", "age", 10));
/*将哈希表 key 中的域 field 的值设置为 value ,当且仅当域 field 不存在*/
System.out.println("将哈希表 key 中的域 field 的值设置为 value ,当且仅当域 field 不存在。k6000-hight-180【key-field-value】--jedis.hsetnx====>"+jedis.hsetnx("k6000", "hight", "180"));
System.out.println(); /**************************zset-k7000*************************/
System.out.println("**************************zset-k7000*************************");
/*Redis有序集合zset与普通集合set非常相似,是一个没有重复元素的字符串集合。
不同之处是有序集合的所有成员都关联了一个评分（score） ,
这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。
集合的成员是唯一的,但是评分可以是重复了 。因为元素是有序的,
所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。
访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。*/
/*将一个 member元素及其 score值加入到有序集 key当中。*/
System.out.println("将一个member元素及其 score值加入到有序集 key当中。k7000-50-v7050【key-score-value】--jedis.zadd====>"+jedis.zadd("k7000", 50, "v7050"));
/*参数Map*/
Map<String, Double> zsetmap = new HashMap<String, Double>();
zsetmap.put("v7060", 60.0);
zsetmap.put("v7070", 70.0);
/*将多个member元素及其 score值加入到有序集 key当中。*/
System.out.println("将多个member元素及其 score值加入到有序集 key当中。"
+ "k7000。v7060-60.0,v7070-70.0【key-score-value】--jedis.zadd====>"+jedis.zadd("k7000", zsetmap));
System.out.println(); /*从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素*/
System.out.println("从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素。从0开始。\n"
+ "k7000-0-10000【key-start-stop】--jedis.zrange====>"+jedis.zrange("k7000", 0, 10000));
/*从大到小排列,返回有序集 key中,下标在<start> <stop>之间的元素*/
System.out.println("从大到小排列,返回有序集 key中,下标在<start> <stop>之间的元素。从0开始。\n"
+ "k7000-0-10000【key-start-stop】--jedis.zrevrange====>"+jedis.zrevrange("k7000", 0, 10000));
System.out.println(); /*从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素带WITHSCORES,可以让分数一起和值返回到结果集。*/
System.out.println(
"从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素,"
+ "带WITHSCORES,可以让分数一起和值返回到结果集。从0开始。"
+ "\n k7000-0-10000【key-start-stop】--jedis.zrangeWithScores");
Set<Tuple> zrangeWithScores = jedis.zrangeWithScores("k7000", 0, 10000);
/*遍历*/
for(Tuple t : zrangeWithScores) {
System.out.println("值:" + t.getElement() + ",分数:" + t.getScore());
}
/*从大到小排列,返回有序集 key中,下标在<start> <stop>之间的元素带WITHSCORES,可以让分数一起和值返回到结果集。*/
System.out.println(
"从大到小排列,返回有序集 key中,下标在<start> <stop>之间的元素,"
+ "带WITHSCORES,可以让分数一起和值返回到结果集。从0开始。"
+ "\n k7000-0-10000【key-start-stop】--jedis.zrevrangeWithScores");
Set<Tuple> zrevrangeWithScores = jedis.zrevrangeWithScores("k7000", 0, 10000);
/*遍历*/
for(Tuple t : zrevrangeWithScores) {
System.out.println("值:" + t.getElement() + ",分数:" + t.getScore());
}
System.out.println(); /*从小到大排列,返回有序集 key中,所有 score值介于min和 max之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。*/
System.out.println("从小到大排列,返回有序集 key中,所有 score值介于min和 max之间(包括等于 min 或 max )的成员\n" +
" 有序集成员按 score 值递增(从小到大)次序排列。从0开始。"
+ "\n k7000-0-1000【key-min-max】--jedis.zrangeByScore====>"
+jedis.zrangeByScore("k7000", 0, 1000));
/*从大到小排列,返回有序集 key中,所有 score值介于min和 max之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从大到小)次序排列。*/
System.out.println("从大到小排列,返回有序集 key中,所有 score值介于min和 max之间(包括等于 min 或 max )的成员\n" +
" 有序集成员按 score 值递增(从小到大)次序排列。从0开始。"
+ "\n k7000-0-1000【key-min-max】--jedis.zrevrangeByScore====>"
+jedis.zrevrangeByScore("k7000", 1000, 0) + "\n"); /*从小到大排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。*/
System.out.println("从小到大排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。\n" +
" 有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。"
+ "\n k7000-0-1000【key-min-max】--jedis.zrangeByScoreWithScores"
);
Set<Tuple> zrangeByScoreWithScores = jedis.zrangeByScoreWithScores("k7000", 0, 1000);
/*遍历*/
for(Tuple t : zrangeByScoreWithScores) {
System.out.println("值:" + t.getElement() + ",分数:" + t.getScore());
}
/*从大到小排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。*/
System.out.println("从大到小排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。\n" +
" 有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。"
+ "\n k7000-0-1000【key-min-max】--jedis.zrevrangeByScoreWithScores"
);
Set<Tuple> zrevrangeByScoreWithScores = jedis.zrevrangeByScoreWithScores("k7000", 1000, 0);
/*遍历*/
for(Tuple t : zrevrangeByScoreWithScores) {
System.out.println("值:" + t.getElement() + ",分数:" + t.getScore());
}
System.out.println(); /*分页。从小到大排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。*/
System.out.println("分页。从小到大排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。\r\n" +
" 有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。"
+ "\n k7000-0-1000-0-2【key-min-max-offset-count】--jedis.zrangeByScoreWithScores");
Set<Tuple> fenyezrangeByScoreWithScores = jedis.zrangeByScoreWithScores("k7000", 0, 1000, 0, 2);
/*遍历*/
for(Tuple t : fenyezrangeByScoreWithScores) {
System.out.println("值:" + t.getElement() + ",分数:" + t.getScore());
}
/*分页。从大到小排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。*/
System.out.println("分页。从大到小排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。\r\n" +
" 有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。"
+ "\n k7000-0-1000-0-2【key-min-max-offset-count】--jedis.zrevrangeByScoreWithScores");
Set<Tuple> fenyezrevrangeByScoreWithScores = jedis.zrevrangeByScoreWithScores("k7000", 1000, 0, 0, 2);
/*遍历*/
for(Tuple t : fenyezrevrangeByScoreWithScores) {
System.out.println("值:" + t.getElement() + ",分数:" + t.getScore());
}
System.out.println(); /*为元素的score加上增量*/
System.out.println("为元素的score加上增量。k7000-5-v7060【key-score-value】--jedis.zincrby====>"+jedis.zincrby("k7000", 5, "v7060"));
/*从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素带WITHSCORES,可以让分数一起和值返回到结果集。*/
System.out.println(
"从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素,"
+ "带WITHSCORES,可以让分数一起和值返回到结果集。从0开始。"
+ "\n k7000-0-10000【key-start-stop】--jedis.zrangeWithScores");
Set<Tuple> zrangeWithScores2 = jedis.zrangeWithScores("k7000", 0, 10000);
/*遍历*/
for(Tuple t : zrangeWithScores2) {
System.out.println("值:" + t.getElement() + ",分数:" + t.getScore());
}
System.out.println(); /*删除该集合下，指定值的元素*/
System.out.println("删除该集合下，指定值的元素。k7000-v7060【key-value】--jedis.zrem====>"+jedis.zrem("k7000", "v7060"));
/*从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素带WITHSCORES,可以让分数一起和值返回到结果集。*/
System.out.println(
"从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素,"
+ "带WITHSCORES,可以让分数一起和值返回到结果集。从0开始。"
+ "\n k7000-0-10000【key-start-stop】--jedis.zrangeWithScores");
Set<Tuple> zrangeWithScores3 = jedis.zrangeWithScores("k7000", 0, 10000);
/*遍历*/
for(Tuple t : zrangeWithScores3) {
System.out.println("值:" + t.getElement() + ",分数:" + t.getScore());
}
System.out.println(); /*统计该集合，分数区间内的元素个数*/
System.out.println("统计该集合，分数区间内的元素个数。从0开始。k7000-0-1000【key-min-max】--jedis.zcount====>"
+jedis.zcount("k7000", 0, 1000)); /*返回该值在集合中的排名，从0开始。*/
System.out.println("返回该值在集合中的排名，从0开始。k7000-v7070【key-value】--jedis.zrank====>"
+jedis.zrank("k7000", "v7070")); /*关闭Redis连接*/
System.out.println("关闭Redis连接");
jedis.close();
}
}
结果：
输出ping结果、PONG表示连接成功:PONG **************************key-k520*************************
遍历输出所有键:
省,市,k1,sex,k3,k4,k5,k6,name,k6000,k7000,k520,k5000,k4000,k999,
判断某个键是否存在。k520【key】--jedis.exists====>true
查看键的类型。k520【key】--jedis.type====>string
删除某个键,1表示删除成功,0表示删除失败。k520【key】--jedis.del====>1
为键值设置过期时间,单位秒。k520-600【key-second】--jedis.expire====>0
查看还有多少秒过期,大于0的数表示剩余秒数,-1表示永不过期,-2表示已过期。k520【key】--jedis.ttl====>-2
查看当前数据库的key的数量--jedis.dbSize====>14
**************************String-k999-k520*************************
查询对应键值。k999【key】--jedis.get====>v9991
添加键值对。k999-v999【key-value】--jedis.set====>OK
将给定的<value> 追加到原值的末尾,输出添加后值的长度。 k999-1【key-value】--jedis.append====>5
获得值的长度。k999【key】--jedis.strlen====>5
只有在 key不存在时设置 key的值,不存在时设置后返回1,存在时不能设置返回0。k520-520【key-value】--jedis.setnx====>1
将 key中储存的数字值增1,只能对数字值操作,如果为空,新增值为1。k520【key】--jedis.incr====>521
将 key中储存的数字值减1,只能对数字值操作,如果为空,新增值为-1。k520【key】--jedis.decr====>520
将 key中储存的数字值增加。自定义步长。k520-100【key-num】--jedis.incrBy,显示增加后的值====>620
将 key中储存的数字值减少。自定义步长。k520-100【key-num】--jedis.decrBy,显示减少后的值====>520
同时设置一个或多个key-value对。name-余杰,sex-男【key-value,key-value】--jedis.mset====>OK
查询对应键值。name, sex【key,key】--jedis.mget====>[余杰, 男]
同时设置一个或多个 key-value 对,当且仅当所有给定 key都不存在。省-福建,市-福州【key-value,key-value】。不存在时设置后返回1,存在时不能设置返回0--jedis.msetnx====>0
获得值的范围,类似java中的substring。从0开始计算。k520-0-1【键-开始(包括)-结尾(包括),key-0-1,表示获取前两位】--jedis.getrange====>52
用 <value>覆写<key> 所储存的字符串值,从<起始位置>开始。k520【从0开始计算,键-起始位置(包括)-值,key-0-99,表示替换前两位为99】--jedis.setrange====>3
设置键值的同时,设置过期时间,单位秒。k520【key-60-888,表示设置key的值为888,且60秒后过期】--jedis.setex====>OK
查看还有多少秒过期,大于0的数表示剩余秒数,-1表示永不过期,-2表示已过期k520【key】--jedis.ttl====>60
以新换旧,设置了新值同时获得旧值。k520【key-001,表示设置key的新值为001,且获取原来的值】--jedis.getSet====>888 **************************List-k2000-k3000*************************
从左边插入一个或多个值。返回插入后的值数量k2000【key-value-value-...】--jedis.lpush====>2
按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>[v2, v1]
从右边插入一个或多个值。返回插入后的值数量k2000【key-value-value-...】--jedis.rpush====>4
按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>[v2, v1, v3, v4]
从左边吐出一个值。值在键在,值亡键亡。k2000【key】--jedis.lpop====>v2
按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>[v1, v3, v4]
从右边吐出一个值。值在键在,值亡键亡。k2000【key】--jedis.rpop====>v4
按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>[v1, v3]
从左边插入一个或多个值。返回插入后的值数量k3000【key-value-value-...】--jedis.lpush====>2
按照索引下标获得元素(从左到右)k3000【key-0-10000】--jedis.lrange====>[v3001, v3000]
从<key1>列表右边吐出一个值,插到<key2>列表左边。k2000【key1,key2】--jedis.rpoplpush====>v3
按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>[v1]
按照索引下标获得元素(从左到右)k3000【key-0-10000】--jedis.lrange====>[v3, v3001, v3000]
按照索引下标获得元素(从左到右)k2000【key-0,获取第一个值】--jedis.lindex====>v1
获得列表长度k2000【key】--jedis.llen====>1
获得列表长度k3000【key】--jedis.llen====>3
在<value>的前面插入<newvalue>k2000【key-LIST_POSITION.BEFORE-value-newvalue】--jedis.linsert====>2
在<value>的后面插入<newvalue>k2000【key-LIST_POSITION.AFTER-value-newvalue】--jedis.linsert====>3
按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>[v2333, v1, v2444]
从左边删除n个value(从左到右)k2000【key-10000-value】--jedis.lrem====>1
按照索引下标获得元素(从左到右)k2000【key-0-10000】--jedis.lrange====>[v2333, v2444]
删除某个键,1表示删除成功,0表示删除失败k2000【key】--jedis.del====>1
删除某个键,1表示删除成功,0表示删除失败k3000【key】--jedis.del====>1 **************************Set-k4000-k5000*************************
将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。k4000【key-value-value-...】--jedis.sadd====>1
取出该集合的所有值。k4000【key】--jedis.smembers====>[v5002, v4001, v4002, v4003]
判断集合<key>是否为含有该<value>值,有返回true,没有返回false。k4000【key-value】--jedis.get====>true
返回该集合的元素个数。k4000【key】--jedis.scard====>4
删除集合中的某个元素。k4000【key-value-value-...】--jedis.srem====>2
取出该集合的所有值。k4000【key】--jedis.smembers====>[v4003, v5002]
将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。k4000【key-value-value-...】--jedis.sadd====>2
取出该集合的所有值。k4000【key】--jedis.smembers====>[v4003, v4001, v5002, v4002]
随机从该集合中吐出一个值。k4000【key】--jedis.spop====>v4001
取出该集合的所有值。k4000【key】--jedis.smembers====>[v4003, v5002, v4002]
随机从该集合中取出1个值。不会从集合中删除。k4000【key】--jedis.get====>v4003
取出该集合的所有值。k4000【key】--jedis.smembers====>[v4003, v5002, v4002]
随机从该集合中取出n个值。不会从集合中删除。k4000【key-num】--jedis.get====>[v5002, v4003]
取出该集合的所有值。k4000【key】--jedis.smembers====>[v4003, v5002, v4002]
删除某个键,1表示删除成功,0表示删除失败k4000【key】--jedis.del====>1
删除某个键,1表示删除成功,0表示删除失败k5000【key】--jedis.del====>1
将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。k4000【key-value-value-...】--jedis.sadd====>3
将一个或多个 member元素加入到集合key当中,已经存在于集合的 member元素将被忽略。k5000【key-value-value-...】--jedis.sadd====>3
取出该集合的所有值。k4000【key】--jedis.smembers====>[v5002, v4001, v4003]
取出该集合的所有值。k5000【key】--jedis.smembers====>[v5003, v5002, v4001]
返回两个集合的交集元素。【key1-key2】--jedis.sinter====>[v5002, v4001]
返回两个集合的并集元素。【key1-key2】--jedis.sunion====>[v4003, v5003, v5002, v4001]
返回两个集合的差集元素。【key1-key2】--jedis.sdiff====>[v4003] **************************hash-k6000*************************
给<key>集合中的 <field>键赋值<value>。k6000-name-yujie【key-field-value】--jedis.hset====>0
从<key1>集合<field> 取出 value。k6000-name【key-field】--jedis.hget====>yujie
批量设置hash的值。k6000。age-18,sex-man【key-map】--jedis.hmset====>OK
查看哈希表 key 中,给定域 field 是否存在。k6000-name【key-field】--jedis.hexists====>true
列出该hash集合的所有field。k6000【key】--jedis.hkeys====>[name, hight, age, sex]
列出该hash集合的所有value。k6000【key】--jedis.hvals====>[yujie, 18, man, 180]
为哈希表 key 中的域 field 的值加上增量 increment。k6000-age -10【key-field-num】--jedis.hincrBy====>28
将哈希表 key 中的域 field 的值设置为 value ,当且仅当域 field 不存在。k6000-hight-180【key-field-value】--jedis.hsetnx====>0 **************************zset-k7000*************************
将一个member元素及其 score值加入到有序集 key当中。k7000-50-v7050【key-score-value】--jedis.zadd====>0
将多个member元素及其 score值加入到有序集 key当中。k7000。v7060-60.0,v7070-70.0【key-score-value】--jedis.zadd====>1 从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素。从0开始。
k7000-0-10000【key-start-stop】--jedis.zrange====>[v7050, v7060, v7070]
从大到小排列,返回有序集 key中,下标在<start> <stop>之间的元素。从0开始。
k7000-0-10000【key-start-stop】--jedis.zrevrange====>[v7070, v7060, v7050] 从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素,带WITHSCORES,可以让分数一起和值返回到结果集。从0开始。
k7000-0-10000【key-start-stop】--jedis.zrangeWithScores
值:v7050,分数:50.0
值:v7060,分数:60.0
值:v7070,分数:70.0
从大到小排列,返回有序集 key中,下标在<start> <stop>之间的元素,带WITHSCORES,可以让分数一起和值返回到结果集。从0开始。
k7000-0-10000【key-start-stop】--jedis.zrevrangeWithScores
值:v7070,分数:70.0
值:v7060,分数:60.0
值:v7050,分数:50.0 从小到大排列,返回有序集 key中,所有 score值介于min和 max之间(包括等于 min 或 max )的成员
有序集成员按 score 值递增(从小到大)次序排列。从0开始。
k7000-0-1000【key-min-max】--jedis.zrangeByScore====>[v7050, v7060, v7070]
从大到小排列,返回有序集 key中,所有 score值介于min和 max之间(包括等于 min 或 max )的成员
有序集成员按 score 值递增(从小到大)次序排列。从0开始。
k7000-0-1000【key-min-max】--jedis.zrevrangeByScore====>[v7070, v7060, v7050] 从小到大排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。
k7000-0-1000【key-min-max】--jedis.zrangeByScoreWithScores
值:v7050,分数:50.0
值:v7060,分数:60.0
值:v7070,分数:70.0
从大到小排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。
k7000-0-1000【key-min-max】--jedis.zrevrangeByScoreWithScores
值:v7070,分数:70.0
值:v7060,分数:60.0
值:v7050,分数:50.0 分页。从小到大排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。
k7000-0-1000-0-2【key-min-max-offset-count】--jedis.zrangeByScoreWithScores
值:v7050,分数:50.0
值:v7060,分数:60.0
分页。从大到小排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。
k7000-0-1000-0-2【key-min-max-offset-count】--jedis.zrevrangeByScoreWithScores
值:v7070,分数:70.0
值:v7060,分数:60.0 为元素的score加上增量。k7000-5-v7060【key-score-value】--jedis.zincrby====>65.0
从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素,带WITHSCORES,可以让分数一起和值返回到结果集。从0开始。
k7000-0-10000【key-start-stop】--jedis.zrangeWithScores
值:v7050,分数:50.0
值:v7060,分数:65.0
值:v7070,分数:70.0 删除该集合下，指定值的元素。k7000-v7060【key-value】--jedis.zrem====>1
从小到大排列,返回有序集 key中,下标在<start> <stop>之间的元素,带WITHSCORES,可以让分数一起和值返回到结果集。从0开始。
k7000-0-10000【key-start-stop】--jedis.zrangeWithScores
值:v7050,分数:50.0
值:v7070,分数:70.0 统计该集合，分数区间内的元素个数。从0开始。k7000-0-1000【key-min-max】--jedis.zcount====>2
返回该值在集合中的排名，从0开始。k7000-v7070【key-value】--jedis.zrank====>1