Jedis常用命令

心已赠人 2022-07-12 06:18 171阅读 0赞

# 操作各种数据类型的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");
    
         }