RedisTemplate访问Redis数据结构（五）——ZSet
Redis 有序集合和无序集合一样也是string类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个double类型的分数。有序集合的成员是唯一的,但分数(score)却可以重复。redis正是通过分数来为集合中的成员进行从小到大的排序。
ZSetOperations提供了一系列方法对有序集合进行操作。首先初始化spring工厂获得redisTemplate和opsForZSet
private RedisTemplate<String,Object> redisTemplate;
private ZSetOperations<String, Object> opsForZSet; @SuppressWarnings("unchecked")
@Before
public void before(){
@SuppressWarnings("resource")
ApplicationContext context = new ClassPathXmlApplicationContext("/applicationContext.xml");
redisTemplate = (RedisTemplate<String,Object>)context.getBean("redisTemplate");
opsForZSet = redisTemplate.opsForZSet();
}
Boolean add(K key, V value, double score);
Set< V > range(K key, long start, long end);
@Test
public void testAdd(){
redisTemplate.delete("fan1");
//将值添加到键中的排序集合，如果已存在，则更新其分数。
System.out.println(opsForZSet.add("fan1", "a", 1));//true （这里的1.0可以用1代替,因为用double收参）
ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<Object>("b",2.0);//这里必须是2.0，因为那边是用Double收参
ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<Object>("c",3.0);
Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<ZSetOperations.TypedTuple<Object>>();
tuples.add(objectTypedTuple1);
tuples.add(objectTypedTuple2);
System.out.println(opsForZSet.add("fan1",tuples));//2
//通过索引区间返回有序集合指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
System.out.println(opsForZSet.range("fan1",0,-1));//[a, b, c]
}
Long remove(K key, Object… values);
@Test
public void testRemove(){
redisTemplate.delete("fan2");
opsForZSet.add("fan2", "a", 1);
System.out.println(opsForZSet.range("fan2", 0, -1));//[a]
opsForZSet.remove("fan2", "a");
System.out.println(opsForZSet.range("fan2", 0, -1));//[]
}
public Set< K > keys(K pattern)
Double incrementScore(K key, V value, double delta);
@Test
public void testIncrementScore(){
redisTemplate.delete("fan3");
System.out.println(redisTemplate.keys("fan3"));//[]
//通过增量增加排序集中的元素的分数
System.out.println(opsForZSet.incrementScore("fan3", "a", -1));//-1.0(可见默认技术为0)
System.out.println(redisTemplate.keys("fan3"));//[fan3]
}
Long rank(K key, Object o);
@Test
public void testRank(){
redisTemplate.delete("fan4");
opsForZSet.add("fan4", "a", 1);
opsForZSet.add("fan4", "b", 3);
opsForZSet.add("fan4", "c", 2);
opsForZSet.add("fan4", "d", -1);
System.out.println(opsForZSet.range("fan4", 0, -1));//[d, a, c, b]（从小到大）
//在排序集中确定具有值的元素的索引,并返回其索引(从低到高)
System.out.println(opsForZSet.rank("fan4", "b"));//3(从小到大且从零开始)
}
Long reverseRank(K key, Object o);
@Test
public void testReverseRank(){
redisTemplate.delete("fan5");
opsForZSet.add("fan5", "a", 1);
opsForZSet.add("fan5", "b", 3);
opsForZSet.add("fan5", "c", 2);
opsForZSet.add("fan5", "d", -1);
//当从高到低时，确定排序集中的值的元素的索引。
System.out.println(opsForZSet.reverseRank("fan5", "b"));//0(从大到小且从零开始)
}
Set< TypedTuple< V >> rangeWithScores(K key, long start, long end);
@Test
public void testRangeWithScores(){
redisTemplate.delete("fan6");
opsForZSet.add("fan6", "a", 1);
opsForZSet.add("fan6", "b", 3);
opsForZSet.add("fan6", "c", 2);
opsForZSet.add("fan6", "d", -1);
//从排序集中获取开始和结束之间的元组(Tuple)。
Set<TypedTuple<Object>> rangeWithScores = opsForZSet.rangeWithScores("fan6", 0 , -1);
Iterator<TypedTuple<Object>> iterator = rangeWithScores.iterator();
while(iterator.hasNext()){
TypedTuple<Object> next = iterator.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:d score:-1.0
value:a score:1.0
value:c score:2.0
value:b score:3.0
*/
}
}
Set< V > rangeByScore(K key, double min, double max);
@Test
public void testRangeByScore(){
redisTemplate.delete("fan7");
opsForZSet.add("fan7", "a", 1);
opsForZSet.add("fan7", "b", 3);
opsForZSet.add("fan7", "c", 2);
opsForZSet.add("fan7", "d", -1);
//得到分数在最小和最大值之间的元素。(从小到大)
Set<Object> rangeByScore = opsForZSet.rangeByScore("fan7", 1, 2);
System.out.println(rangeByScore);//[a, c]
//从开始到结束的范围内获取元素，其中分数在分类集合的最小值和最大值之间。
Set<Object> rangeByScore2 = opsForZSet.rangeByScore("fan7", 0, 10, 0, -1);
System.out.println(rangeByScore2);//[a, c, b]
Set<Object> rangeByScore3 = opsForZSet.rangeByScore("fan7", -1, 3, 0, 1);
System.out.println(rangeByScore3);//[d]
}
Set< TypedTuple< V >> rangeByScoreWithScores(K key, double min, double max);
Set< TypedTuple< V >> rangeByScoreWithScores(K key, double min, double max, long offset, long count);
@Test
public void testRangeByScoreWithScores(){
redisTemplate.delete("fan8");
opsForZSet.add("fan8", "a", 1);
opsForZSet.add("fan8", "b", 3);
opsForZSet.add("fan8", "c", 2);
opsForZSet.add("fan8", "d", -1);
//得到一组元组，其中分数在分类集合的最小值和最大值之间
Set<TypedTuple<Object>> rangeByScoreWithScores = opsForZSet.rangeByScoreWithScores("fan8", 1, 2);//注意("fan8",2,1)是获取不到数据的
Iterator<TypedTuple<Object>> iterator = rangeByScoreWithScores.iterator();
while(iterator.hasNext()){
TypedTuple<Object> next = iterator.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:a score:1.0
value:c score:2.0
*/
}
//从开始到结束的范围内获取一组元组，其中分数在分类集中的最小值和最大值之间。
Set<TypedTuple<Object>> rangeByScoreWithScores2 = opsForZSet.rangeByScoreWithScores("fan8", 1, 2, 1, 2);
Iterator<TypedTuple<Object>> iterator2 = rangeByScoreWithScores2.iterator();
while(iterator2.hasNext()){
TypedTuple<Object> next = iterator2.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:c score:2.0
*/
}
}
Set reverseRange(K key, long start, long end);
Set< TypedTuple< V >> reverseRangeWithScores(K key, long start, long end);
Set< V > reverseRangeByScore(K key, double min, double max);
Set< TypedTuple< V >> reverseRangeByScoreWithScores(K key, double min, double max);
Set< V > reverseRangeByScore(K key, double min, double max, long offset, long count);
Set< TypedTuple< V >> reverseRangeByScoreWithScores(K key, double min, double max, long offset, long count);
@Test
public void testReverseRange(){
redisTemplate.delete("fan9");
opsForZSet.add("fan9", "a", 1);
opsForZSet.add("fan9", "b", 3);
opsForZSet.add("fan9", "c", 2);
opsForZSet.add("fan9", "d", -1);
//从从高到低的排序集中获取从头(start)到尾(end)内的元素。
Set<Object> reverseRange = opsForZSet.reverseRange("fan9", 0, -1);
System.out.println(reverseRange);//[b, c, a, d]
//从开始(start)到结束(end)，从排序从高到低的排序集中获取元组的集合
Set<TypedTuple<Object>> reverseRangeWithScores = opsForZSet.reverseRangeWithScores("fan9", 0, -1);
Iterator<TypedTuple<Object>> iterator = reverseRangeWithScores.iterator();
while(iterator.hasNext()){
TypedTuple<Object> next = iterator.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:b score:3.0
value:c score:2.0
value:a score:1.0
value:d score:-1.0
*/
}
//从高到低的排序集中获取分数在最小和最大值之间的元素。
Set<Object> reverseRangeByScore = opsForZSet.reverseRangeByScore("fan9", -1, 2);
System.out.println(reverseRangeByScore);//[c, a, d]
//从开始到结束的范围内获取元素，其中分数在最小和最大之间，从排序集排序高 - >低。
Set<Object> reverseRangeByScore2 = opsForZSet.reverseRangeByScore("fan9", -1, 2, 2, 3);
System.out.println(reverseRangeByScore2);//[d]
//得到一组元组，其中分数在最小和最大之间，从排序从高到低
Set<TypedTuple<Object>> reverseRangeByScoreWithScores = opsForZSet.reverseRangeByScoreWithScores("fan9", -1, 2);
Iterator<TypedTuple<Object>> iterator2 = reverseRangeByScoreWithScores.iterator();
while(iterator2.hasNext()){
TypedTuple<Object> next = iterator2.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:c score:2.0
value:a score:1.0
value:d score:-1.0
*/
}
//从开始到结束的范围内获取一组元组，其中分数在最小和最大之间，从排序集排序高 - >低。
Set<TypedTuple<Object>> reverseRangeByScoreWithScores2 = opsForZSet.reverseRangeByScoreWithScores("fan9", -1, 2, 1, 3);
Iterator<TypedTuple<Object>> iterator3 = reverseRangeByScoreWithScores2.iterator();
while(iterator3.hasNext()){
TypedTuple<Object> next = iterator3.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:a score:1.0
value:d score:-1.0
*/
} }
Long count(K key, double min, double max);
@Test
public void testCount(){
redisTemplate.delete("fan10");
opsForZSet.add("fan10", "a", 1);
opsForZSet.add("fan10", "b", 3);
opsForZSet.add("fan10", "c", 2);
opsForZSet.add("fan10", "d", -1);
//计算排序集中在最小和最大分数之间的元素数。
Long count = opsForZSet.count("fan10", -1, 2);
System.out.println(count);//
}
Long size(K key);
Long zCard(K key);
@Test
public void testSizeAndZCard(){
redisTemplate.delete("fan11");
opsForZSet.add("fan11", "a", 1);
opsForZSet.add("fan11", "b", 3);
opsForZSet.add("fan11", "c", 2);
opsForZSet.add("fan11", "d", -1);
//返回使用给定键存储的排序集的元素数(其实size()底层就是调用的zCard())
Long size = opsForZSet.size("fan11");
System.out.println(size);//4
//使用键获取排序集的大小。
Long zCard = opsForZSet.zCard("fan11");
System.out.println(zCard);//
}
Double score(K key, Object o);
@Test
public void testScore(){
redisTemplate.delete("fan12");
opsForZSet.add("fan12", "a", 1);
opsForZSet.add("fan12", "b", 3);
opsForZSet.add("fan12", "c", 2);
opsForZSet.add("fan12", "d", -1);
//使用键值从排序集中获取具有值的元素的分数
Double score = opsForZSet.score("fan12", "b");
System.out.println(score);//3.0
}
Long removeRange(K key, long start, long end);
@Test
public void testRemoveRange(){
redisTemplate.delete("fan13");
opsForZSet.add("fan13", "a", 1);
opsForZSet.add("fan13", "b", 3);
opsForZSet.add("fan13", "c", 2);
opsForZSet.add("fan13", "d", -1);
//使用键从排序集中删除开始和结束之间范围内的元素
Long removeRange = opsForZSet.removeRange("fan13", 1, 3);
System.out.println(removeRange);//
System.out.println(opsForZSet.zCard("fan13"));//
}
Long removeRangeByScore(K key, double min, double max);
@Test
public void testRemoveRangeByScore(){
redisTemplate.delete("fan13");
opsForZSet.add("fan13", "a", 1);
opsForZSet.add("fan13", "b", 3);
opsForZSet.add("fan13", "c", 2);
opsForZSet.add("fan13", "d", -1);
//使用键从排序集中移除最小和最大值之间的元素
Long removeRangeByScore = opsForZSet.removeRangeByScore("fan13", 2, 100);
System.out.println(removeRangeByScore);//
}
Long unionAndStore(K key, K otherKey, K destKey);
Long unionAndStore(K key, Collection< K > otherKeys, K destKey);
@Test
public void testUnionAndStore(){
redisTemplate.delete("fan14");
redisTemplate.delete("fan15");
redisTemplate.delete("fan16");
redisTemplate.delete("fan17");
redisTemplate.delete("fan18");
opsForZSet.add("fan14", "a", 1);
opsForZSet.add("fan14", "b", 3);
opsForZSet.add("fan14", "c", 2);
opsForZSet.add("fan14", "d", -1); opsForZSet.add("fan15", "c", 1);
opsForZSet.add("fan15", "d", 3);
opsForZSet.add("fan15", "e", 2);
opsForZSet.add("fan15", "f", -1);
//在键和其他键上的联合排序集合，并将结果存储在目标destIny中(注意相交的元素分数相加)
Long unionAndStore = opsForZSet.unionAndStore("fan14", "fan15", "fan16");
System.out.println(unionAndStore);//
Set<TypedTuple<Object>> rangeWithScores = opsForZSet.rangeWithScores("fan16", 0, -1);
Iterator<TypedTuple<Object>> iterator = rangeWithScores.iterator();
while(iterator.hasNext()){
TypedTuple<Object> next = iterator.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:f score:-1.0
value:a score:1.0
value:d score:2.0
value:e score:2.0
value:b score:3.0
value:c score:3.0 可以看出，score相加了
*/
}
opsForZSet.add("fan17", "e", 5);
opsForZSet.add("fan17", "f", -7);
opsForZSet.add("fan17", "g", 31);
opsForZSet.add("fan17", "h", -11);
opsForZSet.add("fan17", "c", -11);
//计算给定的多个有序集的并集，并存储在新的 destKey中
Long unionAndStore2 = opsForZSet.unionAndStore("fan14", Arrays.asList("fan15","fan17"), "fan18");
System.out.println(unionAndStore2);//
Set<TypedTuple<Object>> rangeWithScores2 = opsForZSet.rangeWithScores("fan18", 0, -1);
Iterator<TypedTuple<Object>> iterator2 = rangeWithScores2.iterator();
while(iterator2.hasNext()){
TypedTuple<Object> next = iterator2.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:h score:-11.0
value:c score:-8.0
value:f score:-8.0
value:a score:1.0
value:d score:2.0
value:b score:3.0
value:e score:7.0
value:g score:31.0
*/
}
}
Long intersectAndStore(K key, K otherKey, K destKey);
Long intersectAndStore(K key, Collection< K > otherKeys, K destKey);
@Test
public void testIntersectAndStore(){
redisTemplate.delete("fan19");
redisTemplate.delete("fan20");
redisTemplate.delete("fan21");
redisTemplate.delete("fan22");
redisTemplate.delete("fan23");
opsForZSet.add("fan19", "a", 1);
opsForZSet.add("fan19", "b", 3);
opsForZSet.add("fan19", "c", 2);
opsForZSet.add("fan19", "d", -1); opsForZSet.add("fan20", "c", 1);
opsForZSet.add("fan20", "d", 3);
opsForZSet.add("fan20", "e", 8);
opsForZSet.add("fan20", "f", -5); opsForZSet.add("fan21", "e", 1);
opsForZSet.add("fan21", "f", 3);
opsForZSet.add("fan21", "g", 2);
opsForZSet.add("fan21", "h", -1);
opsForZSet.add("fan21", "c", 9);
//计算给定的一个与另一个有序集的交集并将结果集存储在新的有序集合 key 中
Long intersectAndStore = opsForZSet.intersectAndStore("fan19", "fan20", "fan22");
System.out.println(intersectAndStore);//
Set<TypedTuple<Object>> rangeWithScores = opsForZSet.rangeWithScores("fan22", 0, -1);
Iterator<TypedTuple<Object>> iterator = rangeWithScores.iterator();
while(iterator.hasNext()){
TypedTuple<Object> next = iterator.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:d score:2.0
value:c score:3.0
*/
}
//计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中
Long intersectAndStore2 = opsForZSet.intersectAndStore("fan19", Arrays.asList("fan20","fan21"), "fan23");
System.out.println(intersectAndStore2);//
Set<TypedTuple<Object>> rangeWithScores2 = opsForZSet.rangeWithScores("fan23", 0, -1);
Iterator<TypedTuple<Object>> iterator2 = rangeWithScores2.iterator();
while(iterator2.hasNext()){
TypedTuple<Object> next = iterator2.next();
System.out.println("value:"+next.getValue()+" score:"+next.getScore());
/*
value:c score:12.0
*/
}
}
Cursor< TypedTuple< V >> scan(K key, ScanOptions options);
@Test
public void testScan(){
redisTemplate.delete("fan24");
opsForZSet.add("fan24", "a", 1);
opsForZSet.add("fan24", "b", 3);
opsForZSet.add("fan24", "c", 2);
opsForZSet.add("fan24", "d", -1);
//跟iterator一毛一样，遍历集合
Cursor<TypedTuple<Object>> scan = opsForZSet.scan("fan24", ScanOptions.NONE);
while (scan.hasNext()){
ZSetOperations.TypedTuple<Object> item = scan.next();
System.out.println(item.getValue() + ":" + item.getScore());
/*
d:-1.0
a:1.0
c:2.0
b:3.0
*/
}
}
转载自：https://blog.csdn.net/weixin_37490221/article/details/78135815
RedisTemplate访问Redis数据结构（五）——ZSet的更多相关文章
- 如何使用RedisTemplate访问Redis数据结构之Zset
Redis的ZSet数据结构 Redis 有序集合和无序集合一样也是string类型元素的集合,且不允许重复的成员. 不同的是每个元素都会关联一个double类型的分数.redis正是通过分数来为集合 ...
- RedisTemplate访问Redis数据结构（前言）
Redis五种基本数据结构 redis提供键值对的形式对数据进行存储.支持五种数据类型:String(字符串),List(链表),Hash(散列),Set(无序集合),ZSet(有序集合).下面是网上 ...
- RedisTemplate访问Redis数据结构
https://www.jianshu.com/p/7bf5dc61ca06 Redis 数据结构简介 Redis 可以存储键与5种不同数据结构类型之间的映射,这5种数据结构类型分别为String(字 ...
- RedisTemplate访问Redis数据结构（介绍和常用命令）
Redis 数据结构简介 Redis 可以存储键与5种不同数据结构类型之间的映射,这5种数据结构类型分别为String(字符串).List(列表).Set(集合).Hash(散列)和 Zset(有序集 ...
- 如何使用RedisTemplate访问Redis数据结构之字符串操作
Redis 数据结构简介 Redis 可以存储键与5种不同数据结构类型之间的映射,这5种数据结构类型分别为String(字符串).List(列表).Set(集合).Hash(散列)和 Zset(有序集 ...
- 如何使用RedisTemplate访问Redis数据结构
RedisTemplate介绍 spring封装了RedisTemplate对象来进行对redis的各种操作,它支持所有的 redis 原生的api. RedisTemplate在spring代码中的 ...
- Redis(九):使用RedisTemplate访问Redis数据结构API大全
RedisTemplate介绍 spring封装了RedisTemplate对象来进行对redis的各种操作,它支持所有的 redis 原生的api. RedisTemplate在spring代码中的 ...
- 如何使用RedisTemplate访问Redis数据结构之list
Redis的List数据结构 这边我们把RedisTemplate序列化方式改回之前的 Jackson2JsonRedisSerializer<Object> jackson2JsonRe ...
- RedisTemplate访问Redis数据结构（一）——String
当对String数据结构进行操作时,推荐直接使用spring-data-redis提供的StringRedisTemplate,其配置如下 <bean id="stringRedisT ...
随机推荐
- 【Linux开发】【DSP开发】利用CCS6.1生成out文件的同时生成bin文件
[Linux开发][DSP开发]利用CCS6.1生成out文件的同时生成bin文件 标签:[DSP开发] [Linux开发] 尝试在windows上安装的CCS6.1开发AM4378-Linux下的应 ...
- linux应用程序启动时加载库错误问题
ldd text查看依赖库 ln -s /lib64/libpcre.so.0 /usr/local/lib/libpcre.so做软连接
- Java基础语法-运算符
1算术运算符 1.1运算符和表达式 运算符:对常量和变量进行操作的符号. 表达式:用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式. 不同运算符链接的表达式体现的是不同类型的表达式 ...
- 第六周总结&第四次实验报告
实验四 类的继承 一. 实验目的 (1) 掌握类的继承方法: (2) 变量的继承和覆盖,方法的继承.重载和覆盖实现: 二. 实验内容 三.实验过程 实验代码 package Shiyan4; publ ...
- 使用Postwoman
postman的脱单产品postwoman 一.安装 1.使用git进行安装: git clone https://github.com/liyasthomas/postwoman cd postwo ...
- tarjan算法应用 割点 桥 双连通分量
tarjan算法的应用. 还需多练习--.遇上题目还是容易傻住 对于tarjan算法中使用到的Dfn和Low数组. low[u]:=min(low[u],dfn[v])--(u,v)为后向边,v不是u ...
- [FJOI2007]轮状病毒 题解(dp(找规律)+高精度)
[FJOI2007]轮状病毒 题解(dp(找规律)+高精度) 标签:题解 阅读体验:https://zybuluo.com/Junlier/note/1335733 没什么好说的,直接把规律找出来,有 ...
- shell学习笔记2---执行Shell脚本（多种方法）
在新进程中运行 Shell 脚本 1) 将 Shell 脚本作为程序运行 切换到脚本所在位置(还要给脚本加上可执行权限) [mozhiyan@localhost demo]$ ./test.sh #执 ...
- checkbox的全选、全消的使用
jquery的选择器的使用 //全选,全消 $("#check_all").click(function () { state = $(this).prop("check ...
- solr集群搭建(SolrCloud)
SolrCloud(solr 云)是 Solr 提供的分布式搜索方案,当你需要大规模,容错,索引量很大,搜索请求并发很高时可以使用SolrCloud.它是基于 Solr 和Zookeeper的分布式搜 ...