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();
}
}
