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开始。
"
                + "k7000-0-10000【key-start-stop】--jedis.zrange====>"+jedis.zrange("k7000", 0, 10000));
        /*从大到小排列,返回有序集 key中,下标在<start> <stop>之间的元素*/
        System.out.println("从大到小排列,返回有序集 key中,下标在<start> <stop>之间的元素。从0开始。
"
                + "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开始。"
                + "
    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开始。"
                + "
    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 )的成员
" + 
                "             有序集成员按 score 值递增(从小到大)次序排列。从0开始。"
                + "
 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 )的成员
" + 
                "             有序集成员按 score 值递增(从小到大)次序排列。从0开始。"
                + "
 k7000-0-1000【key-min-max】--jedis.zrevrangeByScore====>"
                +jedis.zrevrangeByScore("k7000", 1000, 0) + "
");
        
        /*从小到大排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
             有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。*/        
        System.out.println("从小到大排列,返回有序集 key 中,所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
" + 
                "             有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。"
                + "
 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 )的成员。
" + 
                "             有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。"
                + "
 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 )的成员。
" + 
                "        有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。"
                + "
 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 )的成员。
" + 
                "        有序集成员按 score 值递增(从小到大)次序排列,可以让分数一起和值返回到结果集。从0开始。"
                + "
 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开始。"
                + "
    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开始。"
                + "
    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