Redis学习笔记(6)-SortedSet

package cn.com;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;

/**
 * 有序集合的所有操作方法
 *
 * */
public class Redis_SortedSet {

	public static Jedis redis = new Jedis("localhost", 6379);// 连接redis

	/**
	 * ZADD key score member [[score member] [score member] ...]
	 * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
	 * 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
	 * score 值可以是整数值或双精度浮点数。
	 * 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
	 * 当 key 存在但不是有序集类型时，返回一个错误。
	 * */
	public static void zadd(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}

	}

	/**
	 * 返回有序集 key 的基数。
	 * */
	public static void zcard(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		Long length=redis.zcard("user");
		System.out.println(length);
	}

	/**
	 * ZCOUNT key min max
	 * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
	 * */
	public static void zcount(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		Long number=redis.zcount("user", 5,9);
		System.out.println(number);

	}

	/**
	 * ZINCRBY key increment member
	 *为有序集 key 的成员 member 的 score 值加上增量 increment 。
	 *可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
	 *当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
	 *当 key 不是有序集类型时，返回一个错误。
	 *score 值可以是整数值或双精度浮点数
	 * */
	public static void zincrby(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		redis.zincrby("user", 55,"age5");
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
	 * 计算给定的一个或多个有序集的交集，其中给定 key 的数量必须以 numkeys 参数指定，并将该交集(结果集)储存到 destination 。
	 * 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之和.
	 * */
	public static void zinterstore(){
		redis.flushDB();//清除数据

		redis.zadd("user", 1, "age1");
		redis.zadd("user", 3, "age3");
		redis.zadd("user", 6, "age6");
		redis.zadd("user", 2, "age2");
		redis.zadd("user", 8, "age8");

		redis.zadd("user1", 11, "age1");
		redis.zadd("user1", 33, "age3");
		redis.zadd("user1", 66, "age6");
		redis.zadd("user1", 22, "age2");
		redis.zadd("user1", 88, "age8");
		redis.zadd("user1", 99, "age9");

		redis.zinterstore("newset",new String[]{"user","user1"});

		Set<String> list=redis.zrange("newset", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
	 * 可选的 LIMIT 参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集，此过程最坏复杂度为 O(N) 时间。
	 * 可选的 WITHSCORES 参数决定结果集是单单返回有序集的成员，还是将有序集成员及其 score 值一起返回。
	 * */
	public static void zrangeByScore(){
		redis.flushDB();//清除数据
		redis.zadd("user", 1, "age1");redis.zadd("user", 11, "age11");redis.zadd("user", 111, "age111");
		redis.zadd("user", 3, "age3");redis.zadd("user", 33, "age33");redis.zadd("user", 333, "age333");
		redis.zadd("user", 6, "age6");redis.zadd("user", 66, "age6");redis.zadd("user", 666, "age666");
		redis.zadd("user", 2, "age2");redis.zadd("user", 22, "age22");redis.zadd("user", 222, "age222");
		redis.zadd("user", 8, "age8");redis.zadd("user", 9, "age9");redis.zadd("user", 9, "age9");
		Set<String> list=redis.zrangeByScore("user", 100, 700);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * ZRANK key member
	 * 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
	 * 排名以 0 为底，也就是说， score 值最小的成员排名为 0 。
	 * */
	public static void rand(){
		redis.flushDB();
		redis.zadd("user", 1, "age1");redis.zadd("user", 11, "age11");redis.zadd("user", 111, "age111");
		long number=redis.zrank("user", "age11");
		//number 显示的位1 低名是从0 开始 age11 排名为第一
		System.out.println(number);
	}

	/**
	 * ZREM key member [member ...]
 	 * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
	 * 当 key 存在但不是有序集类型时，返回一个错误
	 * */
	public static void zrem(){
		redis.flushDB();
		redis.zadd("user", 1, "age1");
		redis.zadd("user", 2, "age2");
		redis.zadd("user", 3, "age3");
		redis.zadd("user", 4, "age4");
		redis.zadd("user", 5, "age5");
		redis.zrem("user", "age2","age5");
		Set<String> list=redis.zrange("user",0,-1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 取排名在stat -end 之间的Tuple (strt 和end 指的指的是在集合中的排名 并非是score)
	 * Tuple 包含key 和 score
	 * */
	public static void zrangeWithScores(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 33, "age3");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		Set<Tuple> list= redis.zrangeWithScores("user", 0, 2);
		for(Tuple s:list){
			System.out.println(s.getElement()+" store:"+s.getScore());

		}
	}

	/**
	 * 取排名在stat -end 之间的Tuple (strt 和end 指的是存储的score )
	 * Tuple 包含key 和 score
	 * */
	public static void zrangeByScoreWithScores(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 33, "age3");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		Set<Tuple> list=redis.zrangeByScoreWithScores("user", 0, 35);
		for(Tuple s:list){
			System.out.println(s.getElement()+" store:"+s.getScore());

		}
	}

	/**
	 * 删除 排序号在 strt-end 之间的元素
	 * */
	public static void zremrangeByRank(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 333, "age33");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		redis.zadd("user", 66, "age6");
		redis.zadd("user", 77, "age7");
		redis.zremrangeByRank("user", 0, 3);
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 倒序排列集合
	 * @param key (max最大score) (min 最小score)
	 * */
	public static void zrevrangeByScore(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 333, "age33");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		Set<String> list=redis.zrevrangeByScore("user", 55, 0);

		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 倒序取score 范围 max-min 之间的元素
	 * */
	public static void zrevrangeByScoreWithScores(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 333, "age33");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		redis.zadd("user", 66, "age6");
		redis.zadd("user", 77, "age7");
		Set<Tuple> list=	redis.zrevrangeByScoreWithScores("user", 66, 22);
		for(Tuple s:list){
			System.out.println(s.getElement()+" store:"+s.getScore());
		}
	}

	/**
	 * 倒序排列集合
	 * @param key star-end 取排序范围
	 * */
	public static void zrevrangeWithScores(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 333, "age33");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		Set<Tuple> list=redis.zrevrangeWithScores("user", 0, 3);

		for(Tuple s:list){
			System.out.println(s.getElement()+" score:"+s.getScore());
		}
	}

	/**
	 * 删除 key 在 score的值在star-end 之间的值
	 * */
	public static void zremrangeByScore(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 33, "age3");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		redis.zremrangeByScore("user", 0, 22);
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	/**
	 * 返回 key 中member 中的排名值
	 * */
	public static void zrevrank(){
		redis.flushDB();
		redis.zadd("user", 11, "age1");
		redis.zadd("user", 22, "age2");
		redis.zadd("user", 33, "age3");
		redis.zadd("user", 44, "age4");
		redis.zadd("user", 55, "age5");
		long l=redis.zrevrank("user", "age3");

		System.out.println(l);

	}

	/**
	 * 返回有序集 key 中，指定区间内的成员。
	 * 其中成员的位置按 score 值递增(从小到大)来排序。
	 * 具有相同 score 值的成员按字典序(lexicographical order )来排列。
	 * */
	public static void zrange(){
		redis.flushDB();//清除数据
		Map<String,Double> agemap=new HashMap<String,Double>();
		agemap.put("age1", 1.0);
		agemap.put("age2", 2.0);
		agemap.put("age4", 4.0);
		agemap.put("age3", 3.0);
		agemap.put("age9", 9.0);
		agemap.put("age5", 5.0);
		redis.zadd("user", agemap);
		redis.zincrby("user", 55,"age5");
		Set<String> list=redis.zrange("user", 0, -1);
		for(String s:list){
			System.out.println(s);
		}

	}

	/**
	 * 求两个集合的并集
	 * */
	public static void zunionstore(){
		redis.flushDB();//清除数据
		redis.zadd("user", 1, "age1");
		redis.zadd("user", 3, "age3");
		redis.zadd("user", 6, "age6");
		redis.zadd("user", 2, "age2");
		redis.zadd("user", 10, "age10");

		redis.zadd("user1", 11, "age1");
		redis.zadd("user1", 33, "age3");
		redis.zadd("user1", 66, "age6");
		redis.zadd("user1", 22, "age2");
		redis.zadd("user1", 88, "age8");
		redis.zadd("user1", 99, "age9");

		redis.zunionstore("newset",new String[]{"user","user1"});
		Set<String> list=redis.zrange("newset", 0, -1);
		for(String s:list){
			System.out.println(s);
		}
	}

	public static void main(String [] args){
		zrevrangeByScoreWithScores();
	}
}