Redis教程
redis灵魂拷问：聊一聊zset使用
本文主要是介绍redis灵魂拷问：聊一聊zset使用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
目录
数据结构回顾
常用命令
添加
删除
获取元素个数
获取区间内元素个数
获取元素索引
获取区间内元素
获取所有元素
查看或增加分数
交集和并集
pop命令
使用场景
1.阅读量排行榜
2.销售量排行榜
3.手机号幸运抽奖
总结
本文介绍一下redis中zset的使用。首先说一下我本地的实验环境：
redis版本:6.0.7
springboot-redis版本：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.1.6.RELEASE</version> </dependency>
里面使用到的spring-data-redis版本：2.1.9.RELEASE
里面使用到的lettuce连接池版本：5.1.7.RELEASE
数据结构回顾
之前在文章《redis灵魂拷问：聊一聊redis底层数据结构》中讲过redis的数据结构了，zset用到了3种数据结构，压缩列表、跳表，并且使用哈希表来保存value:score键值对。
当同时满足下面2个条件时会用到压缩列表，否则会用跳表：
- 集合中元素都小于64字节
- 集合中元素个数小于128个
当然这个也是可以配置的，在redis.conf文件中：
# Similarly to hashes and lists, sorted sets are also specially encoded in # order to save a lot of space. This encoding is only used when the length and # elements of a sorted set are below the following limits: zset-max-ziplist-entries 128 zset-max-ziplist-value 64
因为使用哈希表保存分数，所以zset查找分数的命令时间复杂度是o(1)。
跳表的数据结构我们再回顾一下，看下图;
跳表中的元素是按照分数有序排列的，每个元素都有指向后一个元素的指针，所以跳表可以很方便地进行范围查询，查找一个元素的复杂度是O(log(N)),从这个元素通过指针就可以找到后面的M个元素，所以复杂度是O(log(N)+M)。
常用命令
注意：下面的命令我用java代码来实现，注解中写了每个命令的原生命令和时间复杂度，使用的时候大家可以根据每个命令的复杂度来进行取舍。
添加
/**
* ZADD
* 时间复杂度 O(log(N)),n是sorted set中元素个数
*/
public void add(){
//批量添加
Set<DefaultTypedTuple> zset1 = new HashSet<>();
zset1.add(new DefaultTypedTuple("v1",30.0));
zset1.add(new DefaultTypedTuple("v2",20.0));
zset1.add(new DefaultTypedTuple("v3",40.0));
zset1.add(new DefaultTypedTuple("v4",10.0));
//单个添加
redisTemplate.opsForZSet().add("zset1", zset1);
//加入后排序[v5, v4, v2, v1, v3]
redisTemplate.opsForZSet().add("zset1", "v5", 5);
}删除
/**
* ZREM
* 复杂度O(M*log(N))
* @return 删除元素个数
*/
public Long remove(){
Set<DefaultTypedTuple> zset6 = new HashSet<>();
zset6.add(new DefaultTypedTuple("v1",30.0));
zset6.add(new DefaultTypedTuple("v2",20.0));
zset6.add(new DefaultTypedTuple("v3",40.0));
zset6.add(new DefaultTypedTuple("v4",10.0));
zset6.add(new DefaultTypedTuple("v5",5.0));
redisTemplate.opsForZSet().add("zset6", zset6);
//返回2
return redisTemplate.opsForZSet().remove("zset6", "v4", "v5");
}
/**
* ZREMRANGEBYRANK
* 复杂度O(log(N)+M)
* @return 删除元素个数
*/
public Long removeRange(){
Set<DefaultTypedTuple> zset7 = new HashSet<>();
zset7.add(new DefaultTypedTuple("v1",10.0));
zset7.add(new DefaultTypedTuple("v2",20.0));
zset7.add(new DefaultTypedTuple("v3",30.0));
zset7.add(new DefaultTypedTuple("v4",40.0));
zset7.add(new DefaultTypedTuple("v5",50.0));
redisTemplate.opsForZSet().add("zset7", zset7);
//返回3,此时zset中只剩[v1,v5]
return redisTemplate.opsForZSet().removeRange("zset7", 1, 3);
}
/**
* ZREMRANGEBYSCORE
* 复杂度O(log(N)+M)
* @return 删除元素个数
*/
public Long removeRangeByScore(){
Set<DefaultTypedTuple> zset8 = new HashSet<>();
zset8.add(new DefaultTypedTuple("v1",10.0));
zset8.add(new DefaultTypedTuple("v2",20.0));
zset8.add(new DefaultTypedTuple("v3",30.0));
zset8.add(new DefaultTypedTuple("v4",40.0));
zset8.add(new DefaultTypedTuple("v5",50.0));
redisTemplate.opsForZSet().add("zset8", zset8);
//返回3,此时zset中只剩[v4,v5]
return redisTemplate.opsForZSet().removeRangeByScore("zset8", 10, 30);
}获取元素个数
/**
* ZCARD
* 返回元素个数
* 复杂度 O(1)
*
* @return
*/
public Long zCard(){
Set<DefaultTypedTuple> zset1 = new HashSet<>();
zset1.add(new DefaultTypedTuple("v1",30.0));
zset1.add(new DefaultTypedTuple("v2",20.0));
zset1.add(new DefaultTypedTuple("v3",40.0));
zset1.add(new DefaultTypedTuple("v4",10.0));
zset1.add(new DefaultTypedTuple("v5",5.0));
redisTemplate.opsForZSet().add("zset1", zset1);
//[v5, v4, v2, v1, v3],返回5
return redisTemplate.opsForZSet().zCard("zset1");
}获取区间内元素个数
/**
* ZCOUNT
* 时间复杂度O(log(N))
* 返回分数是min~max之间的元素个数, 闭区间
* @return
*/
public Long count(){
Set<DefaultTypedTuple> zset1 = new HashSet<>();
zset1.add(new DefaultTypedTuple("v1",30.0));
zset1.add(new DefaultTypedTuple("v2",20.0));
zset1.add(new DefaultTypedTuple("v3",40.0));
zset1.add(new DefaultTypedTuple("v4",10.0));
zset1.add(new DefaultTypedTuple("v5",5.0));
redisTemplate.opsForZSet().add("zset1", zset1);
//["v1",30.0, "v2",20.0, "v3",40.0, "v4",10.0, "v5",5.0],返回2
return redisTemplate.opsForZSet().count("zset1", 20.0, 30.0);
}获取元素索引
/**
* ZRANK
* 时间复杂度O(log(N))
*
* @return 返回元素的正序索引位置
*/
public Long rank(){
Set<DefaultTypedTuple> zset1 = new HashSet<>();
zset1.add(new DefaultTypedTuple("v1",30.0));
zset1.add(new DefaultTypedTuple("v2",20.0));
zset1.add(new DefaultTypedTuple("v3",40.0));
zset1.add(new DefaultTypedTuple("v4",10.0));
zset1.add(new DefaultTypedTuple("v5",5.0));
redisTemplate.opsForZSet().add("zset1", zset1);
//[v5, v4, v2, v1, v3],这里输出0
return redisTemplate.opsForZSet().rank("zset1", "v5");
}
/**
* ZREVRANK
* 时间复杂度O(log(N))
* 跟rank相反,返回元素逆序的位置
*
* @return 返回元素的逆序索引位置
*/
public Long reverseRank(){
Set<DefaultTypedTuple> zset1 = new HashSet<>();
zset1.add(new DefaultTypedTuple("v1",30.0));
zset1.add(new DefaultTypedTuple("v2",20.0));
zset1.add(new DefaultTypedTuple("v3",40.0));
zset1.add(new DefaultTypedTuple("v4",10.0));
zset1.add(new DefaultTypedTuple("v5",5.0));
redisTemplate.opsForZSet().add("zset1", zset1);
//[v5, v4, v2, v1, v3],这里输出4
return redisTemplate.opsForZSet().reverseRank("zset1", "v5");
}获取区间内元素
/**
* ZRANGE/ZREVRANGE命令
* 复杂度O(log(N)+M),N是有序集合中的元素,M是返回的元素个数
*注意：
* 1.索引下标从0开始
* 2.ZREVRANGE对应逆序输出,这里不给出示例
*
* @return 返回指定索引范围内的元素,注意,这里是闭区间, 如果end传入-1,就是从start到最后一个元素
*/
public Set range(){
Set<DefaultTypedTuple> zset1 = new HashSet<>();
zset1.add(new DefaultTypedTuple("v1",30.0));
zset1.add(new DefaultTypedTuple("v2",20.0));
zset1.add(new DefaultTypedTuple("v3",40.0));
zset1.add(new DefaultTypedTuple("v4",10.0));
zset1.add(new DefaultTypedTuple("v5",5.0));
redisTemplate.opsForZSet().add("zset1", zset1);
//输出[v4, v2, v1, v3],总共5个元素,索引从1开始
return redisTemplate.opsForZSet().range("zset1", 1, -1);
}
/**
* ZRANGEBYLE/ZRANGEBYLEX命令
* 复杂度O(log(N)+M),N是有序集合中的元素,M是返回的元素个数
*注意：
* 1.这个命令用于元素分数相同的有序集合
* 2.spring的RedisZSetCommands.Range不生效
* 3.ZRANGEBYLEX对应逆序输出,当前客户端不支持这个命令
*
* @return 返回指定索引范围内的元素
*/
public Set rangeByLex(){
Set<DefaultTypedTuple> zset3 = new HashSet<>();
zset3.add(new DefaultTypedTuple("a",0d));
zset3.add(new DefaultTypedTuple("b",0d));
zset3.add(new DefaultTypedTuple("c",0d));
zset3.add(new DefaultTypedTuple("d",0d));
zset3.add(new DefaultTypedTuple("e",0d));
zset3.add(new DefaultTypedTuple("f",0d));
zset3.add(new DefaultTypedTuple("g",0d));
redisTemplate.opsForZSet().add("zset3", zset3);
RedisZSetCommands.Range range = RedisZSetCommands.Range.range();
//下面range赋值不生效,给lt赋值后返回空
//range.lt("f");
range.gt("c");
RedisZSetCommands.Limit limit = new RedisZSetCommands.Limit();
limit.offset(0);
limit.count(5);
//返回[a, b, c, d, e]
return redisTemplate.opsForZSet().rangeByLex("zset3", range, limit);
}
/**
* ZRANGEBYSCORE/ZRANGEBYSCORE命令
* 复杂度O(log(N)+M),N是有序集合中的元素,M是返回的元素个数
*注意：
* 这个命令是闭区间
* ZRANGEBYSCORE命令对应逆序输出
*
* @return 返回指定索引范围内的元素
*/
public Set rangeByScore(){
Set<DefaultTypedTuple> zset4 = new HashSet<>();
zset4.add(new DefaultTypedTuple("v1",30.0));
zset4.add(new DefaultTypedTuple("v2",20.0));
zset4.add(new DefaultTypedTuple("v3",40.0));
zset4.add(new DefaultTypedTuple("v4",10.0));
zset4.add(new DefaultTypedTuple("v5",5.0));
redisTemplate.opsForZSet().add("zset4", zset4);
//返回[v4, v2, v1]
return redisTemplate.opsForZSet().rangeByScore("zset4", 10, 30);
}获取所有元素
/**
* ZSCAN命令
* 复杂度O(1)
* 注意：
*
*
* @return 返回指定索引范围内的元素
*/
public void scan(){
Set<DefaultTypedTuple> zset9 = new HashSet<>();
for (int i = 1; i <= 1000; i ++){
zset9.add(new DefaultTypedTuple("v" + i,i * 10.0));
}
redisTemplate.opsForZSet().add("zset9", zset9);
ScanOptions.ScanOptionsBuilder scanOptionsBuilder = new ScanOptions.ScanOptionsBuilder();
//这个count参数其实也不起作用,数据量小,比如20个,我们设置了10,会全部输出；数据量10000个,我们输入2000,也是输出1000个
scanOptionsBuilder.count(2000);
//这里使用v*竟然匹配不到
scanOptionsBuilder.match("*");
Cursor<ZSetOperations.TypedTuple> cursor = redisTemplate.opsForZSet().scan("zset9", scanOptionsBuilder.build());
System.out.println("======================");
cursor.forEachRemaining(r -> System.out.println(r.getValue() + ":" + r.getScore()));
/**
* 下面是输出1000行中的前5行：
* v490:4900.0
* v573:5730.0
* v643:6430.0
* v733:7330.0
* v408:4080.0
*/
}查看或增加分数
/**
* ZINCRBY命令
* 增加元素分数
* 复杂度 O(log(N)),n是zset中元素个数
*
* @return 增加分数后的元素值
*/
public Double incrementScore(){
Set<DefaultTypedTuple> zset5 = new HashSet<>();
zset5.add(new DefaultTypedTuple("v1",30.0));
zset5.add(new DefaultTypedTuple("v2",20.0));
zset5.add(new DefaultTypedTuple("v3",40.0));
zset5.add(new DefaultTypedTuple("v4",10.0));
zset5.add(new DefaultTypedTuple("v5",5.0));
redisTemplate.opsForZSet().add("zset5", zset5);
//返回15.0
return redisTemplate.opsForZSet().incrementScore("zset5", "v5", 10d);
}
/**
* ZSCAN命令
* 复杂度O(1)
* @return 查找元素的分数
*/
public Double score(){
Set<DefaultTypedTuple> zset14 = new HashSet<>();
zset14.add(new DefaultTypedTuple("v1",10.0));
zset14.add(new DefaultTypedTuple("v2",20.0));
zset14.add(new DefaultTypedTuple("v3",30.0));
zset14.add(new DefaultTypedTuple("v4",40.0));
zset14.add(new DefaultTypedTuple("v5",50.0));
redisTemplate.opsForZSet().add("zset14", zset14);
//返回30.0
return redisTemplate.opsForZSet().score("zset14", "v3");
}交集和并集
/**
* ZINTER/ZINTERSTORE
*
* 复杂度O(N*K)+O(M*log(M)) ,N是元素少的zset的元素数量，K是2个zset的元素总数，M是返回结果
*/
public void intersectAndStore(){
Set<DefaultTypedTuple> zset10 = new HashSet<>();
zset10.add(new DefaultTypedTuple("v1",10.0));
zset10.add(new DefaultTypedTuple("v3",30.0));
zset10.add(new DefaultTypedTuple("v5",50.0));
zset10.add(new DefaultTypedTuple("v6",60.0));
redisTemplate.opsForZSet().add("zset10", zset10);
Set<DefaultTypedTuple> zset11 = new HashSet<>();
zset11.add(new DefaultTypedTuple("v1",10.0));
zset11.add(new DefaultTypedTuple("v2",20.0));
zset11.add(new DefaultTypedTuple("v3",30.0));
zset11.add(new DefaultTypedTuple("v4",40.0));
zset11.add(new DefaultTypedTuple("v5",50.0));
redisTemplate.opsForZSet().add("zset11", zset11);
redisTemplate.opsForZSet().intersectAndStore("zset10", "zset11", "zsetinter9and11");
ScanOptions scanOptions = ScanOptions.NONE;
Cursor<ZSetOperations.TypedTuple> cursor = redisTemplate.opsForZSet().scan("zsetinter9and11", scanOptions);
System.out.println("======================");
cursor.forEachRemaining(r -> System.out.println(r.getValue() + ":" + r.getScore()));
/**
* 输出结果如下
* v1:20.0
* v3:60.0
* v5:100.0
*/
}
/**
* ZUNIONSTORE
*
* 复杂度：O(N)+O(M log(M)),其中N是2个zset的元素总数，M是返回的元素个数
*/
public void unionAndStore(){
Set<DefaultTypedTuple> zset12 = new HashSet<>();
zset12.add(new DefaultTypedTuple("v1",10.0));
zset12.add(new DefaultTypedTuple("v2",20.0));
zset12.add(new DefaultTypedTuple("v3",30.0));
redisTemplate.opsForZSet().add("zset12", zset12);
Set<DefaultTypedTuple> zset13 = new HashSet<>();
zset13.add(new DefaultTypedTuple("v4",40.0));
zset13.add(new DefaultTypedTuple("v5",50.0));
zset13.add(new DefaultTypedTuple("v6",60.0));
redisTemplate.opsForZSet().add("zset13", zset13);
redisTemplate.opsForZSet().unionAndStore("zset12", "zset13", "zsetinter12and13");
ScanOptions scanOptions = ScanOptions.NONE;
Cursor<ZSetOperations.TypedTuple> cursor = redisTemplate.opsForZSet().scan("zsetinter12and13", scanOptions);
System.out.println("======================");
cursor.forEachRemaining(r -> System.out.println(r.getValue() + ":" + r.getScore()));
/**
* 输出结果如下
* v1:10.0
* v2:20.0
* v3:30.0
* v4:40.0
* v5:50.0
* v6:60.0
*/
}pop命令
作为队列2个命令：ZPOPMAX/ZPOPMIN,让当前分数最高/最低的元素出队,复杂度O(log(N)*M) ,当前spring版本客户端不支持。
使用场景
zset保存了分数值，所以对于阅读量、点击量排行等场景可以很方便的使用。
1.阅读量排行榜
假如一个博客网站上有10篇文章，我们要统计今天阅读量排名前2位的文章，我们可以先初始化一个10篇文章的zset，代码如下：
Set<DefaultTypedTuple> articles = new HashSet<>();
articles.add(new DefaultTypedTuple("article1",0d));
articles.add(new DefaultTypedTuple("article2",0d));
articles.add(new DefaultTypedTuple("article3",0d));
articles.add(new DefaultTypedTuple("article4",0d));
articles.add(new DefaultTypedTuple("article5",0d));
articles.add(new DefaultTypedTuple("article6",0d));
articles.add(new DefaultTypedTuple("article7",0d));
articles.add(new DefaultTypedTuple("article8",0d));
articles.add(new DefaultTypedTuple("article9",0d));
articles.add(new DefaultTypedTuple("article10",0d));
redisTemplate.opsForZSet().add("articles", articles);每当有1篇文章被阅读时，我们就把分数加1，比如第一篇：
redisTemplate.opsForZSet().incrementScore("articles", "article1", 1d);日终时，我们找出排名前2位的文章:
redisTemplate.opsForZSet().range("articles", 0, 1);2.销售量排行榜
跟上面的场景类似，假如我们要找出销售量前2位的商品，我们也可以初始化一个商品zset，分数就是销售量，每次售出一件商品时分数值加1，最后range命令去除前2个商品。
3.手机号幸运抽奖
比如我们要对1万个手机号排名，我们可以把姓名作为key，把手机号score存入zset中，代码如下：
Set<DefaultTypedTuple> phones = new HashSet<>();
phones.add(new DefaultTypedTuple("张三",18605556899));
redisTemplate.opsForZSet().add("phones", phones);我们可以随便找出一个幸运手机号，比如6000
redisTemplate.opsForZSet().range("articles", 5999, 5999);总结
zset使用了压缩列表、跳表的数据结构，并且使用哈希表来保存value:score键值对。
range命令得益于底层使用了跳表，复杂度并不高，但是会随着返回元素的数量而增加。zscan命令复杂度很低，但是spring提供的api不友好，超过1000需要分页的时候，就不好用了。元素个数少于1000时使用zscan命令一次取出是最快的。
交集并集的复杂度很高，如果有bigkey的情况，会严重阻塞主线程，建议一般不要使用。可以把2个zset的元素取出来，在应用内存中进行交集并集运算，这样不会阻塞redis主线程。
由于api和版本限制，本文并没有列出zset的所有命令，大家可以查看官网：
https://redis.io/commands/zunionstore
这篇关于redis灵魂拷问：聊一聊zset使用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
Redis安装入门：新手必读指南11-18
-
阿里云Redis项目实战入门教程11-08
-
阿里云Redis资料：新手入门与初级使用指南11-08
-
阿里云Redis教程：新手入门及实用指南11-08
-
阿里云Redis学习入门：新手必读指南11-07
-
阿里云Redis学习入门：从零开始的操作指南11-07
-
阿里云Redis学习：初学者指南11-07
-
阿里云Redis入门教程：轻松搭建与使用指南11-06
-
Redis项目实战：新手入门教程11-02
-
Redis入门教程：轻松掌握数据存储与操作10-22
-
Redis缓存入门教程：快速掌握Redis缓存基础知识10-22
-
Redis入门指南：轻松掌握Redis基础操作10-22
-
Redis Quicklist 竟让内存占用狂降50%？10-22
-
Redis学习：从入门到初级应用教程10-17
-
Redis入门：新手必读教程10-12
栏目导航
