20190928-02使用Redis客户端Jedis连接Redis，以及用Java代码操作Redis 000 030

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