Jedis操作Redis

String类型操作

package com.higgin.string;

import java.util.List;
import redis.clients.jedis.Jedis;

/**
 * jedis针对字符串的各种操作
 */
public class StringDemo {
    public static void main(String[] args) {
        
        Jedis jedis = new Jedis("127.0.0.1",6379);
        
        //清空redis中当前所有数据
        jedis.flushDB();
        
        //保存一个字符串
        jedis.set("name", "HigginCui");
        
        //在字符串后面追加一个字符串，如果key不存在，则创建一个新的key
        jedis.append("name", "12345");
        
        //获取一个字符串
        String name =jedis.get("name");
        System.out.println(name);
        
        //自增1,redis会转换成整型，再进行操作，默认为0。返回自增操作后的值
        long count=jedis.incr("count");
        
        //增加指定的值，返回操作后的值
        count=jedis.incrBy("count", 20);
        
        //自减1
        count=jedis.decr("count");
        
        //减少指定的值
        count =jedis.decrBy("count", 100);

        //浮点类型自增指定的数值
        jedis.set("price", "18.80");
        double price=jedis.incrByFloat("price", 5);
        System.out.println(price);
        
        //获取key的旧值，并给其设置新值,返回值是被修改之前的值
        String oldName=jedis.getSet("name", "Higgin");
        System.out.println(oldName);  
        
        //获取指定长度的字符串
        jedis.getrange("name", 0, -1);
        
        //替换字符串部分内容
        jedis.setrange("name", 0, "ab");  //Higgin--->abggin
        
        //只有key不存在的时候才进行保存(key若已经存在不错任何改变，返回0，若不存在，则创建一个key并赋值，返回1)
        long result=jedis.setnx("name", "abc");
        System.out.println(result);    //打印的是0
        result=jedis.setnx("email","1234567@qq.com");
        System.out.println(result);    //打印的是1
        
        //获取字符串的长度
        long len=jedis.strlen("email");
        System.out.println(len);
        
        //设置多个key的值
        jedis.mset("name","Higgin","age","20","sex","man");
        
        //获取多个key的值
        List<String> list= jedis.mget("name","age","sex");
        
        //同时设置多个key，且key不存在(若有一个key已存在，则整个操作都无效，必须所有的key都不存在才有效)
        jedis.msetnx("name","abc123","language","java","phone","1234567890");  //name之前已存在，所以该句代码操作完全无效
        jedis.msetnx("language","java","phone","1234567890");  //两个key之前都不存在，所以都有效
        
        //保存带有效期的key  单位：毫秒
        jedis.psetex("expireKey1", 4000, "66666");
        //保存带有效期的key  单位:秒
        jedis.setex("expireKey2", 5, "777777");
        
        //断开连接
        jedis.quit();  
    }
}

Hash类型的操作

package com.higgin.hash;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import redis.clients.jedis.Jedis;

/**
 * Hash类型的操作 
 */
public class HashDemo {
    
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        
        //清空redis中当前所有数据
        jedis.flushDB();
        
        //添加hash元素,hset每次只能添加一个成员变量
        long r=jedis.hset("user:1001", "name", "higgin");
        r=jedis.hset("user:1001", "age","18");
        System.out.println(r);
        
        //如果key不存在则添加，负责操失败。(key存在返回0，反之返回1)
        r=jedis.hsetnx("user:1001", "name", "6666");
        System.out.println(r);
        r=jedis.hsetnx("user:1001", "email", "123@qq.com");
        System.out.println(r);
        
        //获取某一个key的值
        String name=jedis.hget("user:1001", "name");
        System.out.println(name);
        
        //获取所有字段的map类型数据
        Map<String,String> map=jedis.hgetAll("user:1001");
        for(Entry<String, String> entry:map.entrySet()){
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
        
        //获取所有字段的值
        List<String> values=jedis.hvals("user:1001");
        for(String v:values){
            System.out.println("value:"+v);
        }
        
        //删除某个字段,返回删除成功的个数
        long dr=jedis.hdel("user:1001", "name","email","haha");
        System.out.println(dr);
        
        //判断某个key的field字段是否存在
        boolean b=jedis.hexists("user:1001", "name");
        
        //对某个field累加指定的数值，返回累加后的值(如果希望减，可以给个 负数的参数)
        r=jedis.hincrBy("user:1001", "age", 5);
        System.out.println(r);
        
        //对某个浮点类型的field累加指定的数值
        jedis.hset("user:1001", "height", "170.00");
        double h=jedis.hincrByFloat("user:1001", "height", 2);
        System.out.println(h);
        
        //获取hash的field字段数量
        long num=jedis.hlen("user:1001");
        System.out.println(num);
        
        //设置多个字段的值,如果成功返回"OK"字符串
        Map<String,String> userMap=new HashMap<String,String>();
        userMap.put("name", "Jack");
        userMap.put("age", "19");
        String isOK=jedis.hmset("user:1002",userMap);
        System.out.println(isOK);
        
        //获取多个字段的值
        List<String> list=jedis.hmget("user:1001", "age","name");
        
        
        jedis.quit();
    }
    
    
}

list类型操作

package com.higgin.list;

import java.util.List;
import redis.clients.jedis.Jedis;

/**
 * list 列表的操作
 *
 */
public class ListDemo {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        
        //清空redis中当前所有数据
        jedis.flushDB();
        
        //从左边（头部）添加元素，返回列表的长度
        long len=jedis.lpush("chars", "a","b","c","d");  //此时 chars为：d c b a
        System.out.println(len);
        
        //从右边（尾部）添加元素，返回列表的长度
        len=jedis.rpush("chars", "1","2","3","4","5");  //此时 chars为： d c b a 1 2 3 4 5 
        System.out.println(len);
        
        //获取列表的长度
        len=jedis.llen("chars");
        System.out.println(len);
        
        //获取列表元素，0:索引开始位置
        List<String> list=jedis.lrange("chars", 0, -1);
        for(String s:list){
            System.out.print(s+" ");   //输出  d c b a 1 2 3 4 5
        }
        
                
        //删除指定的相同的元素，返回删除成功的元素个数
        jedis.rpush("fruit", "apple","apple","banana","apple");
        long r=jedis.lrem("fruit", 2, "apple");   //从左往右删除，删除最先出现的2个"apple"元素
        System.out.println("\n"+r);
        list=jedis.lrange("fruit", 0, -1);
        for(String s:list){
            System.out.print(s+" ");   //banana apple 
        }
        
        //弹出列表中的左边第一个元素
        String s=jedis.lpop("chars");
        System.out.println(s);  
        
        //弹出列表右边的最后一个元素
        s=jedis.rpop("chars");
        
        //往列表左边插入元素，列表必须存在，如果不存在，不做任何操作
        jedis.lpushx("char888", "P");
        
        //往列表右边插入元素，列表必须存在，如果不存在，不做任何操作
        jedis.rpushx("chars999", "X");
        
        //修改列表中指定索引的元素
        jedis.lset("chars", 2, "Z");
        
        //返回指定索引的元素
        String str=jedis.lindex("chars", 1);
                
        //截取并保存列表中指定范围内的元素
        jedis.ltrim("chars", 2, 5);  //保留索引为2,3,4,5的四个元素
        
        //弹出chars1的最右边一个元素到chars2列表的最左边
        jedis.rpush("chars1", "a","b","c");      //chars1: a b c
        jedis.rpush("chars2", "1","2","3","4");  //chars2: 1 2 3 4
        jedis.rpoplpush("chars1", "chars2");   //chars1:a b    chars2: c 1 2 3 4 
        
        
        jedis.quit();
    }
}

Set类型操作

package com.higgin.set;

import java.util.List;
import java.util.Set;

import redis.clients.jedis.Jedis;
/**
 * 集合 
 */
public class SetDemo {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        
        //清空redis中当前所有数据
        jedis.flushDB();
        
        //添加元素，返回添加成功的元素个数
        long fruitNum=jedis.sadd("fruits","apple","banana","lemen");
        System.out.println(fruitNum);   //输出3
        fruitNum=jedis.sadd("fruits", "apple","pear","blueberry");
        System.out.println(fruitNum);  //输出2
        
        //查询集合中的元素个数
        fruitNum=jedis.scard("fruits");
        System.out.println(fruitNum);
        
        //取多个集合的差集
        jedis.sadd("school1", "zhangsan","lisi","wangwu");
        jedis.sadd("school2", "zhangsan","maliu");
        Set<String> s1=jedis.sdiff("school1","school2");  //取属于school1，但不属于school2的内容
        System.out.println(s1.size());  //s1中包含"lisi","wangwu"
        //取出school1和school2集合的差集，并存储在school3中
        jedis.sdiffstore("school3","school1", "school2");
        System.out.println(jedis.scard("school3"));
        
        //取多个集合的交集
        jedis.sinter("school1","school2");
        //取school1和school2的交集，存储在school4中
        jedis.sinterstore("school4", "school1","school2");
        
        //取多个集合的并集
        jedis.sunion("school1","school2");
        //取school1和school2的并集，并存储在school5中
        jedis.sunionstore("school5", "school1","school2");
        
        //判断某个元素是否在某个集合中
        boolean b=jedis.sismember("school1", "zhangsan");
        
        //获取集合中的所有元素
        Set<String> school1=jedis.smembers("school1");
        for(String s:school1){
            System.out.println(s);
        }
        
        //从一个集合中移动指定的元素到另外一个集合中(把school1中的"lisi"移动到"school2"中)
        jedis.smove("school1", "school2", "lisi");
        for(String s:jedis.smembers("school2")){
            System.out.println("school2:"+s);
        }
        
        //从集合中随机获取2个元素
        List<String> list=jedis.srandmember("school2",2);
        
        
        //从集合中随机移除一个或多个元素，返回被移除的元素
//        Set<String> popObj=jedis.spop("fruits", 1);
//        System.out.println(popObj);
        
        //从集合中删除一个或多个指定的元素，返回删除的个数
        long remNum=jedis.srem("fruits", "apple","blueberry","123");
        System.out.println(remNum);
        
        
        jedis.quit();
    }
}

带分数的set

package com.higgin.sortedset;

import java.util.Set;

import redis.clients.jedis.Jedis;

/**
 * 带分数的集合
 * @author YH
 *
 */
public class SortedSet {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        
        //清空redis中当前所有数据
        jedis.flushDB();
        
        //添加元素
        jedis.zadd("score", 100, "Higgin");
        jedis.zadd("score", 90, "zhangsan");
        jedis.zadd("score", 80.5, "lisi");
        jedis.zadd("score", 70, "wangwu");
        jedis.zadd("score", 60.5, "maliu");
        jedis.zadd("score", 50, "songqi");
        
        //获取所有元素
        Set<String> set=jedis.zrange("score", 0, -1);
        for(String s :set){
            System.out.println(s);
        }
        
        //获取指定分数范围内的元素的数量
        long count=jedis.zcount("score", 60, 90);  //包含60和90
        System.out.println(count);
        
        //为指定的元素增加分值，返回新的分数
        Double newCount=jedis.zincrby("score", 8, "lisi");
        System.out.println(newCount);
        
        //返回某个元素的分数的排名（从小到大排名,第1名排名为0，第2名排名为1）
        long rank=jedis.zrank("score", "zhangsan");
        System.out.println("rank="+rank);
        
        //返回某个元素的分数的排名（从大到小）
        rank=jedis.zrevrank("score", "zhangsan");
        System.out.println("rank="+rank);
        
        //获取对应的元素的分数
        Double score=jedis.zscore("score", "Higgin");
        System.out.println("score="+score);
        
        //获取指定排名范围内的元素 （按从小到大排序）
        set=jedis.zrange("score", 0, 2);
        for(String s :set){
            System.out.println("--"+s);
        }
        //获取指定排名范围内的元素 （按从大到小排序）
        set=jedis.zrevrange("score", 0, 2);
        for(String s :set){
            System.out.println("~~"+s);
        }        
        
        //删除元素，返回删除成功的元素的数量
        count=jedis.zrem("score", "zhangsan","lisi");
        System.out.println(count);
        
        jedis.quit();
    }
}