启动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

20190928-02使用Redis客户端Jedis连接Redis,以及用Java代码操作Redis 000 030的更多相关文章

  1. java代码操作Redis

    1.导入需要的pom依赖 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEn ...

  2. redis客户端jedis连接和spring结合

    摘自传智博客课程 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="htt ...

  3. Java操作redis客户端Jedis连接集群(Cluster)

    创建JedisCluster类连接redis集群. @Test public void testJedisCluster() throws Exception { //创建一连接,JedisClust ...

  4. 使用java代码操作Redis

    1导入pom.xml依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis ...

  5. Java代码操作Redis的sentinel和Redis的集群Cluster操作

    总共四台机器,crxy99,crxy98分别是主节点和从节点.   crxy97和crxy96是两个监控此主从架构的sentinel节点. 看代码: import org.junit.Test; im ...

  6. 【转】Java代码操作Redis的sentinel和Redis的集群Cluster操作

    总共四台机器,crxy99,crxy98分别是主节点和从节点.   crxy97和crxy96是两个监控此主从架构的sentinel节点. 直接看代码: 1 import org.junit.Test ...

  7. java:redis(java代码操作redis,实体类mapper生成器(generator))

    1.redis_demo Maven  ItemMapper.xml: <?xml version="1.0" encoding="UTF-8" ?> ...

  8. 通过jedis连接redis单机成功,使用redis客户端可以连接集群,但使用JedisCluster连接redis集群一直报Could not get a resource from the pool

    一,问题描述: (如题目)通过jedis连接redis单机成功,使用JedisCluster连接redis集群一直报Could not get a resource from the pool 但是使 ...

  9. redis客户端可以连接集群,但JedisCluster连接redis集群一直报Could not get a resource from the pool

    一,问题描述: (如题目)通过jedis连接redis单机成功,使用JedisCluster连接redis集群一直报Could not get a resource from the pool 但是使 ...

随机推荐

  1. java_内部类、匿名内部类的使用

    内部类 将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类. 内部类的分类 成员内部类,类定义在了成员位置 (类中方法外称为成员位置) 局部内部类,类定义在方法内 成员内部类 ...

  2. Java—io流之打印流、 commons-IO

    打印流 打印流根据流的分类: 字节打印流  PrintStream 字符打印流  PrintWriter /* * 需求:把指定的数据,写入到printFile.txt文件中 * * 分析: * 1, ...

  3. C#LeetCode刷题之#345-反转字符串中的元音字母​​​​​​​(Reverse Vowels of a String)

    问题 该文章的最新版本已迁移至个人博客[比特飞],单击链接 https://www.byteflying.com/archives/3935 访问. 编写一个函数,以字符串作为输入,反转该字符串中的元 ...

  4. .NET或.NET Core Web APi基于tus协议实现断点续传

    前言 前两天我采用技巧式方案基本实现大文件分片上传,这里只是重点在于个人思路和亲身实践,若在实际生产环境要求比较高的话肯定不行,仍存在一些问题需要深入处理,本文继续在之前基础上给出基于tus协议的轮子 ...

  5. JS实例—DOM的增删改

    <!DOCTYPE html><html lang="zh"><head> <meta charset="UTF-8" ...

  6. java如何实现发送邮箱

    package cn.buy.util; import java.security.GeneralSecurityException; import java.util.Properties; imp ...

  7. 如何在 asp.net core 的中间件中返回具体的页面

    前言 在 asp.net core 中,存在着中间件这一概念,在中间件中,我们可以比过滤器更早的介入到 http 请求管道,从而实现对每一次的 http 请求.响应做切面处理,从而实现一些特殊的功能 ...

  8. mac启动 Apache JMeter 5.3 语言选择中文界面出现乱码 问题解决

    问题重现 问题修复 出现这个问题,是因为,语言与外观不兼容导致,语言选“中文”,外观选“Metal” 细心的你,可能发现,为啥要重启2次呢???第一次设置完语言后,在设置外观,发现菜单不能选择,第二次 ...

  9. ArcGIS Pro Add-In插件开发[ArcGIS Pro SDK for .NET]

    本文基于 Windows7 + VS2019 + .NET Framework 4.8 + ArcGIS Pro 2.5 开发和撰写. 目录 开发环境配置 获取ArcGIS Pro 安装VS2019 ...

  10. Java进阶专题(十一) 探究JMM

    前言 ​ JMM即java内存模型,JMM研究的就是多线程下Java代码的执行顺序,共享变量的读写.它定义了Java虚拟机在计算机内存中的工作方式.从抽象角度看,JMM定义了线程和主存之间的抽象关系: ...