Jedis常用命令

操作各种数据类型的key的方法

public static void main(String[] args) {
         Jedis jds = new Jedis("192.168.2.244",6379);
         //==================操作的key的方法 ======================
            //删除指定的
            jds.del("hash");
            //序列化key，并返回被序列化的值
            jds.dump("key");
            //判断key是否存在
            jds.exists("key");
            //从当前库中随机返回一个key
            jds.randomKey();            
            //返回key中存储值 的数据类型
            jds.type("key");
            //返回符合正则的的所有key
            jds.keys("*k*");
            //将key移到数据库2中
            jds.move("key", 2);
            //更改key的名字。旧key不存在时报错。当新key存在时，则将覆盖旧值
            jds.rename("oldKey", "newkey");
            //仅当新key不存在时，才更改旧key名字
            jds.renamenx("oldKey", "newkey");

            //-------------------------设置过期-------------------------------- 

            //给key设置过期时间，单位：秒
            jds.expire("key", 10);
            //给key设置过期时间，值是时间戳
            jds.expireAt("key", 1293840000);
            //移除key的过期时间，key将持久保存
            jds.persist("key");
            //返回key的过期时间
            jds.ttl("key"); 
｝

String

public static void main(String[] args) {
         Jedis jds = new Jedis("192.168.2.244",6379);
          //=========================String方法==============================

            //-----------------------赋值------------------------------   
            //指定key的值，如果key已经存在，则覆盖旧值
            jds.set("key", "value");
            //给key赋值，当key存在时操作无效。避免了值的覆盖
            jds.setnx("key", "value");
            //同时指定多个key-value
            jds.mset("key5","value5","key6","6");
            //同时指定多个key-value，key已经存在的操作无效
            jds.msetnx("key6","value6","key7","7");

            //给key值设置过期时间（单位：秒），如果key存在，则新值会覆盖旧值
            jds.setex("key", 5, "valuex");
            //用value值替换从指定字符的索引开始的子串
            jds.setrange("key", 1, "value");

            //-------------------------更改--------------------------------   

            //将key中存的数字值增1，如果key不存在，则key值会被初始化为0，然后再加1
            //如果值不是数字则返回一个错误
            jds.incr("key6");
            //将key中存的数字值增加指定值，如果key不存在，则key值会被初始化为0，然后再加10
            jds.incrBy("key6", 10);
            //将key中存的数字值增加指定的浮点型值，如果key不存在，则key值会被初始化为0，然后再加
            jds.incrByFloat("key6", 10.0);
            //将key中的值减1，如果key不存在，则先初始化为0再减1
            jds.decr("key6");
            //将key中的值减去指定值，如果key不存在，则先初始化为0再减
            jds.decrBy("key6", 8);
            //在key的值的末尾追加串，如果key不存，直接赋值为当前值
            jds.append("key", "appendValue");

            //-------------------------取值--------------------------------               

            //获取key的值
            jds.get("key");
            //按字符的索引区间返回key的子串，包头也包尾
            jds.getrange("key", 0, 1);
            //将key的值改变，并返回旧值，如果key不存在返回null
            jds.getSet("key", "value1");
            //返回一个或多个key的值
            jds.mget("key","key1");
            //返回key的字符串的长度
            jds.strlen("key");

}

Hash

public static void main(String[] args) {
         Jedis jds = new Jedis("192.168.2.244",6379);
         //=========================    Hash方法    ==============================
             //一个hash表可存储40多亿个键值对，即2的32次方减1个。
         //-------------------------赋值--------------------------------  

             // 1. hset：将名为hash的Hash表的键为key字段赋值为value
             jds.hset("hash", "key", "value");

             // 2. hmset：将多个键值对存进hash表
              Map<String, String> map = new HashMap<String, String>();
              map.put("key1", "value1");
              map.put("key2", "value2");
             jds.hmset("hash", map);

             // 3. hsetnx：只有当hash表中不存在该字段时才赋值。若字段存在，则操作无效
             jds.hsetnx("hash", "key", "22");// 由于key已经存在，所以"22"这个值未生效
             jds.hsetnx("hash", "k", "22");  // 查看k的值为22

        //-------------------------查--------------------------------

             // 4. hget：获取hash表中key键对应的值
             jds.hget("hash", "key");
             // 5. hgetAll：获取hash表中所有键值对，结果是Map类型
             jds.hgetAll("hash");
             // 6. hmget：获取hash表中指定键的值，结果是数组类型
             jds.hmget("hash", "key","key1");
             // 7. hkeys：获取hash表中所有键，结果是数组类型
             jds.hkeys("hash");
             // 8. hvals：获取hash表中所有值，结果是数组类型
             jds.hvals("hash");
             // 9.hexists：查看hash表中是否存在key键
             jds.hexists("hash", "key");
             // 10. hlen：获取hash表中键的个数
             jds.hlen("hash");
             // 11. 迭代hash表中的键值对
            // jds.hscan("hash", "");//未测试

        //-------------------------改--------------------------------

             // 12. hincrBy：将hash表中指定键的整型值加3
             jds.hincrBy("hash", "k", 3);
             // 13. hincrByFloat：将hash表中指定键的浮点型值加3
             jds.hincrByFloat("hash", "k", 3);

        //-------------------------删除--------------------------------

             // 14. hdel：删除hash表中一个或多个键值对
             jds.hdel("hash", "key","key1");
}

List

 public static void main(String[] args) {
         Jedis jds = new Jedis("192.168.2.244",6379);

         //=========================   List方法    ==============================

             //每张列表可存40多亿个元素，即2的32次方减1个。
         //-------------------------赋值--------------------------------
             // 1. lpush：向名为list的List列表头部添加一个或多个值
             jds.lpush("list", "value1","value2");
             // lpushx：将一个值插入到已存在的list列表头部，如果不存在操作无效
             jds.lpushx("list", "value3");//注：只能一次插入一个
             // rpush：将一个或多个值插入列表尾部
             jds.rpush("list", "value100","value101");
             // rpushx：将一个值插入已存在列表尾部，若列表不存在操作无效
             jds.rpushx("list", "value102");//只能插入一个
             // lset：给指定索引赋值，若索引不存在报错
             jds.lset("list", 0, "val");
             // linsert：在指定元素前面或后面插入元素
             jds.linsert("list", LIST_POSITION.BEFORE, "val", "value0");//在val元素前面插入

        //-------------------------删除--------------------------------    

             //弹出列表第一个元素
             jds.lpop("list");
             //弹出列表最后一个元素
             jds.rpop("list");
             //弹出列表最后一个元素，并添加到另一个列表中
             jds.rpoplpush("list", "otherlist");

             // lrem：删除表中count个与value相等的元素
             //count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
             //count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
             //count = 0 : 移除表中所有与 VALUE 相等的值。
             jds.lrem("list", 2, "value");           
             // ltrim：只保留指定区间的元素
             jds.ltrim("list", 0, 5);
             // 5秒.......
             jds.blpop(5, "list");

        //-------------------------取值--------------------------------   
             // llen：获取表的元素个数
             jds.llen("list");
             // lrange：获取指定区间的元素
             jds.lrange("list", 0, jds.llen("list"));
             // lindex：通过索引获取元素
             jds.lindex("list", 0);
｝

Set

 public static void main(String[] args) {
         Jedis jds = new Jedis("192.168.2.244",6379);
         //=========================   Set方法    ==============================   
            //-------------------------添加--------------------------------
             //sadd：向set集合添加一个或多个元素
             jds.sadd("set", "a","b");

            //-------------------------删除--------------------------------            
             //随机返回一个元素并删除
             jds.spop("set");
             //删除集合中一个或多个元素
             jds.srem("set", "a","b");

            //-------------------------更改--------------------------------
             //将一个元素从一个集合中移到另一个集合中
             jds.smove("srckey", "dstkey", "member");
             //返回多个集合的并集
             jds.sunion("set","set1");
             //将多个集合的并集保存到另一个集合中
             jds.sunionstore("dstkey", "set","set1");

            //-------------------------取值--------------------------------
             //scard：返回set集合的元素个数
             jds.scard("set");
             //返回前面集合与后面几个集合的差集
             jds.sdiff("set","set2");
             //将几个集合的差集保存在destSet集合中
             jds.sdiffstore("destSet", "set2","set");
             //返回几个集合的交集
             jds.sinter("set","set2");
             //将几个集合的交集保存在destSet集合中
             jds.sinterstore("destSet", "set","set2");
             //判断a元素是否是set集合的成员
             jds.sismember("set", "a");
             //返回集合中的所有元素
             jds.smembers("set");
             //返回集合中一个或多个随机数
             jds.srandmember("set");
             jds.srandmember("set", 2);
}        

Sorted Set

 public static void main(String[] args) {
         Jedis jds = new Jedis("192.168.2.244",6379);       

        //========================= 有序集合(Sorted set) ==============================

             /*
                Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
                不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
                有序集合的成员是唯一的,但分数(score)却可以重复。
                集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1
              */
         //-------------------------赋值--------------------------------   
             // zadd：将一个或多个元素及其分数值添加到有序集合sortSet中
             // 如果value元素已经存在，则更新分数值，然后根据分数重新插入正确位置
             // 分数值可以是int和double型
             jds.zadd("sortSet", 5, "value");

        //-------------------------更改--------------------------------
             // 将value元素的分值加 2.0。如果值是负数,则为减；如果value元素不存在，则添加
             jds.zincrby("sortSet", 2, "value");
             //将一个或多个有序集合的交集存储在“destkey”集合中
             jds.zinterstore("dstkey", "sortSet","sort");

        //-------------------------删除--------------------------------
             //zrem：删除一个或多个元素
             jds.zrem("sortSet", "value","c");
             //zremrangeByRank：删除指定索引区间的元素（首尾均包含）
             jds.zremrangeByRank("sortSet", 0, 1);
             //zremrangeByScore：删除指定分数之间的元素（首尾均包含）
             jds.zremrangeByScore("sortSet", 5, 10);

        //-------------------------取值--------------------------------    
             // zcard：获取指定有序集合的全部成员数量
             jds.zcard("sortSet");
             // zcount：获取指定分数区间的成员数量
             jds.zcount("sortSet", 0, 10);
             //zrank：返回指定元素的索引值
             jds.zrank("sortSet", "a");
             //zscore：返回指定元素的分数值
             jds.zscore("sortSet", "a");
             //zrevrange：返回指定区间的元素，它们通过 索引、分数从高到低排
             jds.zrevrange("sortSet", 0, 10);
             //zrevrangeByScore：返回指定分数区间的元素，它们通过分数从高到低排列
             jds.zrevrangeByScore("sortSet", 1, 7);
             //zrevrank：返回指定成员的排名，按分数值从大到小排的
             jds.zrevrank("sortSet", "value1");
             //zrange：返回指定索引区间的元素
             jds.zrange("sortSet", 0, 10);
             // 获取全部分元素
             jds.zrange("sortSet", 0, -1);
             // zrangeByScore：返回指定分数值之间的元素
             // 具有相同分数值的元素按字典序排列
             jds.zrangeByScore("sortSet", 0, 20);

        //---------------------2.8.9版本后添加的常用方法，未测-----------------------------   
            // zlexcount:获取指定字典区间的元素个数
            // jds.zlexcount("sortSet", "[a", "[c");
             //zrangeByLex:获得指定字典区间的元素
             //jds.zrangeByLex("sortSet", "[a", "[b");
             //zremrangeByLex：删除指定字典区间的元素
             //jds.zremrangeByLex("sortSet", "(a", "[b");

     }