REDIS提供的map，list，set，sortedset使用测试

public class RedisTest {
	public  JedisPool jedisPool = null;
	
	public void init(){
		//创建配置信息
		JedisPoolConfig pool = new JedisPoolConfig();
    	//设置最大的总链接数
		pool.setMaxTotal(300);
    	//设置最大空闲链接数
		pool.setMaxIdle(100);
    	//设置最大等待时间
		pool.setMaxWaitMillis(10000);
    	//在获取实例的时候进行validate操作，从而使获得的实例都是可用的
		pool.setTestOnBorrow(true);
		//使用配置信息，ip和端口来初始化一个链接池
        jedisPool = new JedisPool(pool,"192.168.0.85", 6379);  
	}
	
	
	
	/**
	 * 
	 * 测试在redis中使用map进行操作
	 * 
	 * 
	 * */
	public void testMap(){
		//获得一个实例
		Jedis jedis = jedisPool.getResource();
		
		//整个map的key（通过这个key来获取map对象）
		String redisMapKey="test_map";
		try {
			//选用数据库13
			jedis.select(13);
			//删除test_map所对应的值（也就是map对象）
			jedis.del(redisMapKey);
			
			/**
			 * 往map中插入key-value开始
			 * */
			//这个语句的意思可理解为：向test_map对应的map中插入一个key为key_1，value为1的key-value对
	        jedis.hset(redisMapKey, "key_1", "1");
			jedis.hset(redisMapKey, "key_2", "2");
			jedis.hset(redisMapKey, "key_3", "3");
			jedis.hset(redisMapKey, "key_4", "4");
			jedis.hset(redisMapKey, "key_5", "5");
			jedis.hset(redisMapKey, "key_6", "6");
			/**
			 * 往map中插入key-value结束
			 * */
			
			
			/*测试map的get操作*/
			System.out.println("test map's get:-----------");
			/*给出map所对应的key(redisMapKey变量)，以及想从map中获得的value的key(key_1)*/
			String hget = jedis.hget(redisMapKey, "key_1");
			System.out.println(hget);
			/*获得map中的所有key值*/
			System.out.println("test get all keys:--------------- ");
			/*给出map所对应的key(redisMapKey变量)*//*返回的key是封装在set中的，因为key是唯一的*/
			Set<String> hkeys = jedis.hkeys(redisMapKey);
			for(String str:hkeys){//输出获得的map的所有key
				System.out.println(str);
			}
			/*获得map中的所有value值*/
			System.out.println("test get all values:------------------");
			/*给出map所对应的key(redisMapKey变量)*//*反悔的值封装在list中，因为value的值是可重复的*/
			List<String> hvals = jedis.hvals(redisMapKey);
			for(String str:hvals){//输出获得的map的所有value
				System.out.println(str);
			}
			/*查询在指定的map中是否包含某个key值对对应的key-value对*/
			System.out.println("test if a key exist in the map:------------------");
			/*给出map所对应的key(redisMapKey变量)和要在该map中查询的key的值*//*如果存在返回true，如果不存在返回false*/
			Boolean hexists = jedis.hexists(redisMapKey, "key_1");
			Boolean hexists2 = jedis.hexists(redisMapKey, "key_100");
			System.out.println("key_1's exit result is: "+hexists+", key_100's exit result is: "+hexists2);
			
			/*获得map中的所有key-value对*/
			System.out.println("test get all :----------------------");
			/*给出map所对应的key(redisMapKey变量)*/
			Map<String, String> hgetAll = jedis.hgetAll(redisMapKey); 
			Set<Entry<String, String>> entrySet = hgetAll.entrySet();
			for(Entry<String, String> en:entrySet){/*输出map中的所有key-value对*/
				System.out.println(en.getKey()+":"+en.getValue());
			}
			
			/*获得map的长度*/
			System.out.println("get the length of hmap:-------------------");
			/*给出map所对应的key(redisMapKey变量)*/
			Long hlen = jedis.hlen(redisMapKey);
			System.out.println(hlen); 
			
			/*对map中的某个key的value进行累加操作*/
			System.out.println("test increment:--------------");
			System.out.println("before increment:");
			List<String> hvals2 = jedis.hvals(redisMapKey);
			for(String str:hvals2){/*输出在累加之前的值*/
				System.out.println(str);
			}
			/*给redisMapKey变量对应的map中的key值为key_6的value的值累加2 返回值是累加后的结果*/
			Long hincrBy = jedis.hincrBy(redisMapKey, "key_6", 2);
			System.out.println("incremnt value is:"+hincrBy);
			System.out.println("after increment:");
			List<String> hvals3 = jedis.hvals(redisMapKey);
			for(String str:hvals3){/*输出在累加之后的值*/
				System.out.println(str);
			}
			
			
			/*删除map中的某个key对对应的key-value对*/
			System.out.println("test del:-----------------------");
			/*给出redisMapKey变量来指出要删除哪个map，然后key_1指出要删除该map中的哪个key-value对*/
			jedis.hdel(redisMapKey, "key_1");
			Set<String> afterDelKeys=jedis.hkeys(redisMapKey);
			for(String str:afterDelKeys){//输出删除操作后map中的所有key值
				System.out.println(str);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedis.close();
		}
	}
	
	
	/**
	 * 
	 * 测试redis中的list
	 * */
	public void testLst(){
		/*获得一个jedis链接实例*/
		Jedis jedis = jedisPool.getResource();
		try {
			/*选择数据库13*/
			jedis.select(13);
			/*向test_lst所对应的list中插入123和223两个值  （可以一直往后写，因为采用的是。。。的传参方式）
			 * 与lpush对应的还有rpush
			 * lpush从左端插入元素，配合lpop就形成了栈，配合rpop就是队列
			 * rpush从右侧插入元素，配合rpop就形成了栈，配合lpup就是队列
			 * 
			 * */
			jedis.lpush("test_lst", "123","223");
			/*获得test_lst中所有的值（从0开始，到-1结束就是所有的值；也可任意设置开始和结束下标）*/
			List<String> lrange = jedis.lrange("test_lst", 0, -1);

			
			System.out.println("before pop:");
			/*输出test_lst的长度*/
			System.out.println("list's length is: " + jedis.llen("test_lst"));
			for(String str:lrange){
				System.out.println(str);
			}
			
			/*向test_lst中下标为0的位置插入一个setted_value*/
			jedis.lset("test_lst", 0, "setted_value");
			/*从test_lst的右端弹出一个值（也有从左端弹出的为lpop），这个值会从lst中移除*/
			/*如果我们一直在下标为0的位置插入元素，然后使用rpop，那么我们模拟的就是队列，先进先出
			 * 如果使用lpop，那么模拟的就是栈，后劲先出
			 * */
			String rpop = jedis.rpop("test_lst");
			System.out.println("rpoped value is : "+rpop);
			
			lrange = jedis.lrange("test_lst", 0, -1);
			System.out.println("after pop:");
			for(String str:lrange){//输出pop操作后的test_lst中的值
				System.out.println(str);
			}
			
			
			System.out.println("after trim");
			/*对test_lst进行裁剪，指定了裁剪的开始位置和结束位置。裁剪之后test_lst只包含[开始位置,结束位置]区间的值*/
			jedis.ltrim("test_lst", 0, 3);
			
			lrange = jedis.lrange("test_lst", 0, -1);
			for(String str:lrange){//输出裁剪结果
				System.out.println(str);
			}
			
			/*从test_lst中移除值为setted_value的第二个值 如果把2换成0，那么所有的setted_value都会被移除*/
			jedis.lrem("test_lst", 2, "setted_value");
			System.out.println("after removed:");                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
			lrange = jedis.lrange("test_lst", 0, -1);
			for(String str:lrange){//输出移除后的test_lst的所有值
				System.out.println(str);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedis.close();
		}  
	}
	
	/**
	 * 
	 * 测试redis中的set
	 * */
	public void testSet(){
		Jedis jedis = jedisPool.getResource();//获得jedis链接实例
		/*两个set 一个叫test_set 一个叫 test_set_two*/
		String redisSetKey="test_set";
		String redisSetKeyTwo="test_set_two";
		try {
			/*选择数据库13，并删除两个set*/
			jedis.select(13);
			jedis.del(redisSetKey);
			jedis.del(redisSetKeyTwo);
			
			
			System.out.println("test set's add:------------------------");
			/*向redisSetKey中添加元素，这里添加了1~6供六个元素*/
			jedis.sadd(redisSetKey, "1","2","3","4","5","6");
			/*向redisSetKeyTwo中添加 2 4 6 8 10 这五个元素*/
			jedis.sadd(redisSetKeyTwo, "2","4","6","8","10");
			System.out.println("test get all memebers of a set:-----------");
			/*获得set中的所有值，返回一个set*/
			Set<String> smembers = jedis.smembers(redisSetKey);
			for(String str:smembers){//遍历输出set中的值
				System.out.println(str);
			}
			System.out.println("test if a member exits in the set:-------------");
			/*分别判断1 和 7 是否属于redisSetKey所指向的set中*/
			Boolean sismember = jedis.sismember(redisSetKey, "1");
			Boolean sismember2 = jedis.sismember(redisSetKey, "7");
			System.out.println("1 in set is:" +sismember+",7 in set is: "+sismember2);
			System.out.println("test del set's memeber:-------------------------");
			/*删除redisSetKey所指向的set中1这个值（set和list不同，所有的值都是唯一的，所以不存在指定要删除的个数一说）*/
			jedis.srem(redisSetKey, "1");
			System.out.println("after del:");
			Set<String> smembers1 = jedis.smembers(redisSetKey);
			for(String str:smembers1){//检验是否成功删除
				System.out.println(str);
			}
			System.out.println("test set's pop:--------------------");
			/*随机从redisSetKey所指向的set中取出一个值（在set中删除并返回）*/
			String spop = jedis.spop(redisSetKey);
			System.out.println("poped value is :"+spop);
			System.out.println("after pop :");
			Set<String> smembers2 = jedis.smembers(redisSetKey);
			for(String str:smembers2){//检验弹出后的set
				System.out.println(str);
			} 
			System.out.println("test set's random:---------------------");
			/*随机从redisSetKey所指向的set中返回一个值（不在set中删除仅返回）*/
			String srandmember = jedis.srandmember(redisSetKey);
			System.out.println("random value is :"+srandmember);
			System.out.println("after random:");
			Set<String> smembers3 = jedis.smembers(redisSetKey);
			for(String str:smembers3){//检验random之后set中是否少了值（检验结果是没有少）
				System.out.println(str);
			}
			
			System.out.println("test set's diff:-------------------");
			/*求一个新的set，这set中包含在redisSetKey中出现但不再redisSetKeyTwo中出现的所有元素（即 redisSetKey-redisSetKeyTwo）*/
			Set<String> sdiff = jedis.sdiff(redisSetKey,redisSetKeyTwo);
			for(String str:sdiff){
				System.out.println(str);
			}
			
			System.out.println("test set's inter:-------------------------");
			/*求一个新的set，这set中包含在redisSetKey中出现且在redisSetKeyTwo中出现的所有元素*/
			Set<String> sinter = jedis.sinter(redisSetKey,redisSetKeyTwo);
			for(String str:sinter){
				System.out.println(str);
			}
			
			System.out.println("test set's unino:-----------------------");
			/*求一个新的set，这set中包含在redisSetKey中出现或在redisSetKeyTwo中出现的所有元素*/
			Set<String> sunion = jedis.sunion(redisSetKey,redisSetKeyTwo);
			for(String str:sunion){
				System.out.println(str);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedis.close();
		}
	}
	
	/**
	 * 
	 * 测试有序的set
	 * */
	public void testSortSet(){
		/*获得redis链接实例*/
		Jedis jedis = jedisPool.getResource();
		/*有序的set的key，用来在redis中唯一标识一个有序的set 这里起名为 test_sort*/
		String redisSortedKey="test_sort";
		try {
			/*选用数据库13，并删除以前的test_sort所指向的value*/
			jedis.select(13);
			jedis.del(redisSortedKey);
			
			/*向有序set中插入zero，three，two，one，four这几个单词，
			 * 它们前面的0，3，2，1，4代表他们的分数（score），在有序set中就是根据这个分数进行排序的
			 * */
			jedis.zadd(redisSortedKey, 0, "zero");
			jedis.zadd(redisSortedKey, 3, "three");
			jedis.zadd(redisSortedKey, 2, "two");
			jedis.zadd(redisSortedKey, 1, "one");
			jedis.zadd(redisSortedKey, 4, "four");
			
			
			System.out.println("get the total number:----------------");
			/*获得数据的总数*/
			Long zcard = jedis.zcard(redisSortedKey);
			System.out.println(zcard);
			System.out.println("count the value between min-value and max-value:-----------------");
			/*统计分数在0到2之间的数据的个数,也就是score在[0,2]闭区间上的数据的个数*/
			Long zcount = jedis.zcount(redisSortedKey, 0, 2);
			System.out.println(zcount);
			System.out.println("test range:----------------------------");
			/*获得从开始下标到结束下标的排好序的set中的值（结束为-1，标识全部），同样也是闭区间*/
			Set<String> zrange = jedis.zrange(redisSortedKey, 0,-1);
			for(String str:zrange){
				System.out.println(str);
			}
			System.out.println("test rverse range:----------------------------");
			/*反序 获得从开始下标到结束下标的排好序的set中的值（结束为-1，标识全部），同样也是闭区间*/
			Set<String> zrevrange = jedis.zrevrange(redisSortedKey, 0, -1);
			for(String str:zrevrange){
				System.out.println(str);
			}
			
			System.out.println("test range by score:---------------------");
			/*获得两个分数之间的排好序的set中的值 同样也是闭区间*/
			Set<String> zrangeByScore = jedis.zrangeByScore(redisSortedKey, 2, 3);
			for(String str:zrangeByScore){
				System.out.println(str);
			}
			
			System.out.println("test range with scores:---------------------");
			/*获得从开始下标到结束下标的排好序的set中的值（结束为-1，标识全部），同样也是闭区间 不同的是返回值中包含了值所对应的分数*/
			Set<Tuple> zrangeWithScores = jedis.zrangeWithScores(redisSortedKey, 0, -1);
			for(Tuple tuple:zrangeWithScores){//tuple中封装了element和score对应与元素和分数
				System.out.println(tuple.getElement()+"------"+tuple.getScore());
			}
			System.out.println("test rank:---------------");
			/*获得某个元素在有序set中的排名（也就是排序位置）*/
			Long zrank = jedis.zrank(redisSortedKey, "three");
			System.out.println("the rank of three is :"+zrank);
			System.out.println("test rem:-----------------------------");
			/*删除某个元素*/
			jedis.zrem(redisSortedKey, "three");
			Set<String> zrange1 = jedis.zrange(redisSortedKey, 0,-1);
			for(String str:zrange1){
				System.out.println(str);
			}
			System.out.println("test reverse rank:------------------------");
			/*获得某个元素的倒序排名*/
			Long zrevrank = jedis.zrevrank(redisSortedKey, "four");
			System.out.println(zrevrank);
			System.out.println("test get score:----------------------------------------");
			/*获得某个元素所对应的分数*/
			Double zscore = jedis.zscore(redisSortedKey, "two");
			System.out.println("two's zscore is: "+zscore);
			
		} catch (Exception e) {
		}finally{
			jedis.close();
		}
	}
	
	
	
	
	public static void main(String[] args) {
		RedisTest test = new RedisTest();
		test.init();
		test.testSortSet();
	}
}