Redis數據類型

Redis數據類型

2.1、Redis數據類型

Redis支持五種數據類型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

2.1.1、字符串

String（字符串）是redis最基本的類型，你可以理解成與Memcached一模一樣的類型，一個key對應一個value。string類型是二進制安全的。意思是redis的string可以包含任何數據。比如jpg圖片或者序列化的對象 。string類型是Redis最基本的數據類型，一個鍵最大能存儲512MB。

     public static void testString(){
		@SuppressWarnings("resource")
		Jedis jedis = new Jedis("10.108.169.6");		
		//清空數據庫中的數據，若不刪除該數據會一直存在內存中，其他的連接也能獲得該數據
		jedis.flushDB();		
		//向key-->name中放入了value-->JackGSmith
        jedis.set("name", "JackGSmith");
        //根據key-->name獲取value
        jedis.get("name");
        //使用mset設置多個鍵值對
        jedis.mset("name1","name1_value","name2","name2_value");
        //使用mget獲取多個value
        List<String> list=jedis.mget("name","name1","name2");
        //拼接
        jedis.append("name", " is a name");
        //刪除某個鍵
        jedis.del("name1");
        //一次刪除多個鍵
        jedis.del(new String[]{"key201", "key202"});
        //系統中所有key
        Set<String> keys = jedis.keys("*");
        Iterator<String> it=keys.iterator() ;
        //遍歷
        while(it.hasNext()){   
            String key = it.next();   
            System.out.println(jedis.get(key));   
        }
        //判斷key是否存在
        System.out.println(jedis.exists("name"));
        //獲取value字符串的子串
        jedis.getrange("name",1,5);
        //setnx,key不存在時設置value，返回值爲1;key已存在時，無法設置value，返回0.
        Long i = jedis.setnx("key", "value301");     
        //設置過期時間
        System.out.println("設置 name的過期時間爲5秒:"+jedis.expire("name", 5));
        try{ 
            Thread.sleep(2000); 
        } 
        catch (InterruptedException e){ 
        } 
        // 查看某個key的剩餘生存時間,單位【秒】.永久生存或者不存在的都返回-1
        System.out.println("查看name的剩餘生存時間："+jedis.ttl("name"));
        // 移除某個key的生存時間
        System.out.println("移除name的生存時間："+jedis.persist("name"));
        System.out.println("查看name的剩餘生存時間："+jedis.ttl("name"));
        // 查看key所儲存的值的類型
        System.out.println("查看name所儲存的值的類型："+jedis.type("name"));
        jedis.disconnect(); 
    }
    set(key, value)：給數據庫中名稱爲key的string賦予值value
    get(key)：返回數據庫中名稱爲key的string的value
    getset(key, value)：給名稱爲key的string賦予上一次的value
    mget(key1, key2,…, key N)：返回庫中多個string的value
    setnx(key, value)：添加string，名稱爲key，值爲value
    setex(key, time, value)：向庫中添加string，設定過期時間time
    mset(key N, value N)：批量設置多個string的值
    msetnx(key N, value N)：如果所有名稱爲key i的string都不存在
    incr(key)：名稱爲key的string增1操作
    incrby(key, integer)：名稱爲key的string增加integer
    decr(key)：名稱爲key的string減1操作
    decrby(key, integer)：名稱爲key的string減少integer
    append(key, value)：名稱爲key的string的值附加value
    substr(key, start, end)：返回名稱爲key的string的value的子串

2.1.2、Redis 哈希(Hash)

Redishash 是一個string類型的field和value的映射表，hash特別適合用於存儲對象。Redis 中每個 hash 可以存儲 232 - 1 鍵值對（40多億）。

         public static void testHash(){
		@SuppressWarnings("resource")
		Jedis jedis = new Jedis("10.108.169.6");
		jedis.flushDB();
		//HSET key field value將哈希表key中的域field的值設爲value。   
		jedis.hset("website", "google", "www.google.cn");   
		jedis.hset("website", "baidu", "www.baidu.com");   
		jedis.hset("website", "sina", "www.sina.com");
		//HMSET key field value [field value ...] 同時將多個field - value(域-值)對設置到哈希表key中。   
		Map<String, String> map = new HashMap<String, String>();   
		map.put("cardid", "123456");   
		map.put("username", "jzkangta");   
		jedis.hmset("hash", map);  	
		//HGET key field返回哈希表key中給定域field的值。   
		System.out.println(jedis.hget("hash", "username")); 
		//HMGET key field [field ...]返回哈希表key中，一個或多個給定域的值。   
		List<String> list = jedis.hmget("website","google","baidu","sina");   
		for(int i=0;i<list.size();i++){   
		    System.out.println(list.get(i));   
		}
		//HGETALL key返回哈希表key中，所有的域和值。   
		Map<String,String> map1 = jedis.hgetAll("hash");   
		for(Map.Entry entry: map1.entrySet()) {   
		     System.out.print(entry.getKey() + ":" + entry.getValue() + "\t");   
		} 
		//刪除key field
		jedis.del("hash","username");
		//判斷是否存在
		jedis.hexists("hash", "key003");
		//hkeys(); key返回哈希表key中的所有域
		System.out.println(jedis.hkeys("website"));
		//HVALS key返回哈希表key中的所有值
		System.out.println(jedis.hvals("website"));
		//HLEN key 返回哈希表key中域的數量。
		jedis.hlen("website");
		//HINCRBY key field increment爲哈希表key中的域field的值加上增量increment。
		jedis.hincrBy("hash", "cardid", 7);
		System.out.println(jedis.hget("hash", "cardid"));
		jedis.disconnect(); 
	}
    hset(key, field, value)：向名稱爲key的hash中添加元素field
    hget(key, field)：返回名稱爲key的hash中field對應的value
    hmget(key, (fields))：返回名稱爲key的hash中field i對應的value
    hmset(key, (fields))：向名稱爲key的hash中添加元素field 
    hincrby(key, field, integer)：將名稱爲key的hash中field的value增加integer
    hexists(key, field)：名稱爲key的hash中是否存在鍵爲field的域
    hdel(key, field)：刪除名稱爲key的hash中鍵爲field的域
    hlen(key)：返回名稱爲key的hash中元素個數
    hkeys(key)：返回名稱爲key的hash中所有鍵
    hvals(key)：返回名稱爲key的hash中所有鍵對應的value
    hgetall(key)：返回名稱爲key的hash中所有的鍵（field）及其對應的value

2.1.3、Redis 列表(List)

Redis列表是簡單的字符串列表，按照插入順序排序。你可以添加一個元素導列表的頭部（左邊）或者尾部（右邊）。一個列表最多可以包含 232 - 1 個元素 (4294967295, 每個列表超過40億個元素)。

       public static void testList(){
		@SuppressWarnings("resource")
		Jedis redis = new Jedis("10.108.169.6");
		redis.flushDB();
		//LPUSH key value [value ...]將值value插入到列表key的表頭。   
		redis.lpush("list", "abc");   
		redis.lpush("list", "xzc");   
		redis.lpush("list", "erf");   
		redis.lpush("list1", "abc1");   
		redis.lpush("list1", "xzc1");   
		redis.lpush("list1", "erf1");
		//去除key的某個元素
		System.out.println(redis.lindex("list", 2));		
		//刪除下標0-1區間之內的元素
		System.out.println(redis.ltrim("list1",0,1));
		System.out.println(redis.lrange("list1", 0, -1));
		//llen,獲取key list的長度
		System.out.println(redis.llen("list"));		
		redis.lpop("list");
		System.out.println(redis.lrange("list", 0, -1));
		
		//LRANGE key start stop返回列表key中指定區間內的元素，區間以偏移量start和stop指定。下標(index)參數start和stop都以0爲底，也就是說，以0表示列表的第一個元素，以1表示列表的第二個元素，以此類推。你也可以使用負數下標，以-1表示列表的最後一個元素，-2表示列表的倒數第二個元素，以此類推。   
		List<String> list = redis.lrange("list", 0, -1);   
		for(int i=0;i<list.size();i++){   
		    System.out.println(list.get(i));   
		}
		redis.disconnect(); 
	}
    rpush(key, value)：在名稱爲key的list尾添加一個值爲value的元素
    lpush(key, value)：在名稱爲key的list頭添加一個值爲value的 元素
    llen(key)：返回名稱爲key的list的長度
    lrange(key, start, end)：返回名稱爲key的list中start至end之間的元素
    ltrim(key, start, end)：截取名稱爲key的list
    lindex(key, index)：返回名稱爲key的list中index位置的元素
    lset(key, index, value)：給名稱爲key的list中index位置的元素賦值
    lrem(key, count, value)：刪除count個key的list中值爲value的元素
    lpop(key)：返回並刪除名稱爲key的list中的首元素
    rpop(key)：返回並刪除名稱爲key的list中的尾元素
    blpop(key1, key2,… key N, timeout)：lpop命令的block版本。
    brpop(key1, key2,… key N, timeout)：rpop的block版本。
    rpoplpush(srckey, dstkey)：返回並刪除名稱爲srckey的list的尾元素

2.1.4、Redis 集合(Set)

Redis的Set是string類型的無序集合。集合成員是唯一的，這就意味着集合中不能出現重複的數據。Redis 中 集合是通過哈希表實現的，所以添加，刪除，查找的複雜度都是O(1)。集合中最大的成員數爲 232 - 1 (4294967295,每個集合可存儲40多億個成員)。

       public static void testSet(){
		@SuppressWarnings("resource")
		Jedis redis = new Jedis("10.108.169.6");
		redis.flushDB();
		//SADD key member [member ...]將member元素加入到集合key當中。   
		redis.sadd("testSet", "s1");   
		redis.sadd("testSet", "s2");   
		redis.sadd("testSet", "s3");   
		redis.sadd("testSet", "s4");   
		redis.sadd("testSet", "s5"); 
		redis.sadd("Set", "s1");
		redis.sadd("Set", "s2");
		redis.sadd("Set", "s7");
		//sinter(), 兩個集合之間的交集
		System.out.println(redis.sinter("testSet","Set"));
		//sunion(), 兩個集合之間的並集
		System.out.println(redis.sunion("testSet","Set"));
		//sdiff(), 兩個集合之間的差集
		System.out.println(redis.sdiff("testSet","Set"));
		//獲取Set中元素的數量
		System.out.println(redis.scard("testSet"));
		//移到集合元素
		redis.smove("testSet", "Set", "s3");
		System.out.println(redis.smembers("Set"));
		//SREM key member移除集合中的member元素。   
		redis.srem("testSet", "s5");   
		//隨機返回並刪除名稱爲key的set中一個元素
		redis.spop("testSet");
		//SMEMBERS key返回集合key中的所有成員。   
		Set<String> set = redis.smembers("testSet");   
		Iterator<String> t1=set.iterator() ;   
		while(t1.hasNext()){   
		    Object obj1=t1.next();   
		    System.out.println(obj1);   
		}   

		//SISMEMBER key member判斷member元素是否是集合key的成員。是（true），否則（false）   
		System.out.println(redis.sismember("testSet", "s4")); 
		redis.disconnect(); 
	}
    sadd(key, member)：向名稱爲key的set中添加元素member
    srem(key, member) ：刪除名稱爲key的set中的元素member
    spop(key) ：隨機返回並刪除名稱爲key的set中一個元素
    smove(srckey, dstkey, member) ：移到集合元素
    scard(key) ：返回名稱爲key的set的基數
    sismember(key, member) ：member是否是名稱爲key的set的元素
    sinter(key1, key2,…key N) ：求交集
    sinterstore(dstkey, (keys)) ：求交集並將交集保存到dstkey的集合
    sunion(key1, (keys)) ：求並集
    sunionstore(dstkey, (keys)) ：求並集並將並集保存到dstkey的集合
    sdiff(key1, (keys)) ：求差集
    sdiffstore(dstkey, (keys)) ：求差集並將差集保存到dstkey的集合
    smembers(key) ：返回名稱爲key的set的所有元素
    srandmember(key) ：隨機返回名稱爲key的set的一個元素

2.1.5、Redis 有序集合(sorted set)

Redis有序集合和集合一樣也是string類型元素的集合,且不允許重複的成員。不同的是每個元素都會關聯一個double類型的分數。redis正是通過分數來爲集合中的成員進行從小到大的排序。有序集合的成員是唯一的,但分數(score)卻可以重複。集合是通過哈希表實現的，所以添加，刪除，查找的複雜度都是O(1)。 集合中最大的成員數爲 232 - 1 (4294967295,每個集合可存儲40多億個成員)

      public static void testZSet(){
		@SuppressWarnings("resource")
		Jedis redis = new Jedis("10.108.169.6");
		redis.flushDB();
		redis.zadd("ZSet",2.0,"s1");
		redis.zadd("ZSet",9.0,"s2");
		redis.zadd("ZSet",4.8,"s3");
		redis.zadd("ZSet",2.8,"s4");
		//統計zset集合中權重某個範圍內（1.0——5.0），元素的個數
		System.out.println(redis.zcount("ZSet", 1.0, 5.0));
		//查看Set中s2的權重
		System.out.println(redis.zscore("ZSet", "s2"));
		//按照權重值排序
		System.out.println(redis.zrange("ZSet", 0, -1));//[s1, s4, s3, s2]
		//獲取Set中元素的數量
		System.out.println(redis.zcard("ZSet"));
		redis.zrem("ZSet", "s2");
		System.out.println(redis.zrange("ZSet", 0, -1));//[s1, s4, s3]
		redis.disconnect(); 
	}