Redis 集合（Sorted Set）方法使用详解

- 一、简介
- 二、常用方法
- - 2.1、ZADD
  - 2.2、ZREM
  - 2.3、ZSCORE
  - 2.4、ZINCRBY
  - 2.5、ZCARD
  - 2.6、ZRANK、ZREVRANK
  - 2.7、ZRANGE、ZREVRANGE
  - 2.8、ZRANGEBYSCORE、ZREVRANGEBYSCORE
  - 2.9、ZCOUNT
  - 2.10、ZREMRANGEBYRANK
  - 2.11、ZREMRANGEBYSCORE
  - 2.12、ZINTERSTORE、ZUNIONSTORE
  - 2.13、ZRANGEBYLEX、ZREVRANGEBYLEX
  - 2.14、ZLEXCOUNT
  - 2.15、ZREMRANGEBYLEX
  - 2.16、ZPOPMAX、ZPOPMIN
  - 2.17、BZPOPMAX、BZPOPMIN

一、简介

本文今天主要是集合（Sorted Set）的方法的使用，以及redis对应的Java实现该怎么用。因为篇幅问题，我这里写了一个测试类，引入 RedisTemplate对象，后面例子里就不一一引入了。大家理解就行，如果大家还不知道如何通过Spring Boot 整合redis则可以查看我之前的文章：SpringBoot整合redis（redis支持单节点和集群），这一章注定是枯燥的，但是可能也是实际中反而用得多的，大家看着办了。

package com.alian.datastruct;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class RedisSortedSetTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
}

二、常用方法

2.1、ZADD

ZADD 向有序集合添加一个或多个成员，或者更新已存在成员的分数

语法

ZADD KEY_NAME SCORE1 MEMBER1... SCOREn MEMBERn

命令操作

127.0.0.1:6379> zadd zset1 95.0  taojianwen
(integer) 1
127.0.0.1:6379> zadd zset1 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 3
127.0.0.1:6379> zrange zset1 0 -1
1) "luokaocong"
2) "wanglin"
3) "tangpeng"
4) "taojianwen"

向集合（zset1）中加入一个成员：taojianwen
向集合（zset1）中加入多个成员：tangpeng、wanglin、luokaocong
获取集合（zset1）的成员，得到：luokaocong、wanglin、tangpeng、taojianwen

Java操作

    @Test
    public void zAdd() {
        String redisKey = "zSet1";
        redisTemplate.delete(redisKey);
        // 添加一个成员
        redisTemplate.opsForZSet().add(redisKey, "taojianwen",95.0);

        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 获取成员的信息
        Set<Object> range = redisTemplate.opsForZSet().range(redisKey, 0, -1);
        log.info("获取集合的信息：{}", range);
    }

获取集合的信息：[luokaocong, wanglin, tangpeng, taojianwen]

2.2、ZREM

ZREM 移除有序集合中的一个或多个成员

语法

ZREM KEY_NAME MEMBER [MEMBER ...]

命令操作

127.0.0.1:6379> zadd zset2 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zrem zset2 luokaocong
(integer) 1
127.0.0.1:6379> zrange zset2 0 -1
1) "wanglin"
2) "tangpeng"
3) "taojianwen"

向集合（zset2）中加入多个成员：taojianwen、tangpeng、wanglin、luokaocong
从集合（zset2）中移除成员luokaocong
获取集合（zset2）的成员，得到：wanglin、tangpeng、taojianwen

Java操作

    @Test
    public void zRem() {
        String redisKey = "zSet2";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 移除成员
        Long num = redisTemplate.opsForZSet().remove(redisKey, "luokaocong");
        log.info("移除成员的个数：{}", num);
        // 获取成员的信息
        Set<Object> range = redisTemplate.opsForZSet().range(redisKey, 0, -1);
        log.info("获取集合的信息：{}", range);
    }

移除成员的个数：1
获取集合的信息：[wanglin, tangpeng, taojianwen]

2.3、ZSCORE

ZSCORE 返回有序集中，成员的分数值

语法

ZSCORE KEY_NAME MEMBER

命令操作

127.0.0.1:6379> zadd zset3 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zscore zset3 taojianwen
"95"

向集合（zset3）中加入多个成员：taojianwen、tangpeng、wanglin、luokaocong
从集合（zset3）中获取成员taojianwen的分数，得到：95

Java操作

    @Test
    public void zScore() {
        String redisKey = "zSet3";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 获取成员的分数
        Double score = redisTemplate.opsForZSet().score(redisKey, "taojianwen");
        log.info("获取成员的分数：{}", score);
    }

获取成员的分数：95.0

2.4、ZINCRBY

ZINCRBY 有序集合中对指定成员的分数加上增量 increment

语法

ZINCRBY KEY_NAME increment MEMBER

命令操作

127.0.0.1:6379> zadd zset4 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zincrby zset4 2 taojianwen
"97"
127.0.0.1:6379> zincrby zset4 2 tangpeng
"94"

向集合（zset4）中加入多个成员：taojianwen、tangpeng、wanglin、luokaocong
给集合（zset4）中获取成员 taojianwen 的分数加 2 分，得到：97
给集合（zset4）中获取成员 tangpeng 的分数加 2 分，得到：94

Java操作

    @Test
    public void zIncrBy() {
        String redisKey = "zSet4";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 获取成员的分数
        redisTemplate.opsForZSet().incrementScore(redisKey, "taojianwen",2);
        redisTemplate.opsForZSet().incrementScore(redisKey, "tangpeng",2);
        // 获取成员的分数
        Double score = redisTemplate.opsForZSet().score(redisKey, "taojianwen");
        log.info("成员taojianwen的分数：{}", score);
        Double score2 = redisTemplate.opsForZSet().score(redisKey, "tangpeng");
        log.info("成员tangpeng的分数：{}", score2);
    }

成员taojianwen的分数：97.0
成员tangpeng的分数：94.0

2.5、ZCARD

ZCARD 获取有序集合的成员数

语法

ZCARD KEY_NAME

命令操作

127.0.0.1:6379> zadd zset5 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zcard zset5
(integer) 4

向集合（zset4）中加入多个成员：taojianwen、tangpeng、wanglin、luokaocong
获取集合（zset4）中成员的个数，得到：4

Java操作

    @Test
    public void zCard() {
        String redisKey = "zSet5";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 获取成员的分数
        Long size = redisTemplate.opsForZSet().size(redisKey);
        log.info("成员的个数：{}", size);
    }

成员的个数：4

2.6、ZRANK、ZREVRANK

ZRANK 返回有序集合中指定成员的排名
ZREVRANK 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序

语法

ZRANK KEY_NAME MEMBER
ZREVRANK KEY_NAME MEMBER

命令操作

127.0.0.1:6379> zadd zset6 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zrank zset6 taojianwen
(integer) 3
127.0.0.1:6379> zrank zset6 luokaocong
(integer) 0
127.0.0.1:6379> zrevrank zset6 taojianwen
(integer) 0
127.0.0.1:6379> zrevrank zset6 luokaocong
(integer) 3

ZRANK

排名	0	1	2	3
分值	90.0	91.0	92.0	95.0
成员	luokaocong	wanglin	tangpeng	taojianwen

ZREVRANK

排名	0	1	2	3
分值	95.0	92.0	91.0	90.0
成员	taojianwen	tangpeng	wanglin	luokaocong

Java操作

    @Test
    public void zRankAndZRevRank() {
        String redisKey = "zSet6";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 返回有序集中指定成员的排名
        Long rank1 = redisTemplate.opsForZSet().rank(redisKey,"taojianwen");
        log.info("有序集中指定成员的(升序)排名为：{}", rank1);
        Long rank2 = redisTemplate.opsForZSet().rank(redisKey,"luokaocong");
        log.info("有序集中指定成员的(升序)排名为：{}", rank2);

        Long rank3 = redisTemplate.opsForZSet().reverseRank(redisKey, "taojianwen");
        log.info("有序集中指定成员的(降序)排名为：{}", rank3);
        Long rank4 = redisTemplate.opsForZSet().reverseRank(redisKey, "luokaocong");
        log.info("有序集中指定成员的(降序)排名为：{}", rank4);
    }

有序集中指定成员的(升序)排名为：3
有序集中指定成员的(升序)排名为：0
有序集中指定成员的(降序)排名为：0
有序集中指定成员的(降序)排名为：3

2.7、ZRANGE、ZREVRANGE

ZRANGE 通过索引区间返回有序集合指定区间内的成员
ZREVRANGE 通过索引区间返回有序集合指定区间内的成员，分数从高到低

语法

ZRANGE KEY_NAME start stop [WITHSCORES]
ZREVRANGE KEY_NAME start stop [WITHSCORES]

命令操作

127.0.0.1:6379> zadd zset7 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zrange zset7 0 -1
1) "luokaocong"
2) "wanglin"
3) "tangpeng"
4) "taojianwen"
127.0.0.1:6379> zrevrange zset7 0 -1
1) "taojianwen"
2) "tangpeng"
3) "wanglin"
4) "luokaocong"

ZRANGE

索引	0	1	2	3
分值	90.0	91.0	92.0	95.0
成员	luokaocong	wanglin	tangpeng	taojianwen

ZREVRANGE

索引	0	1	2	3
分值	95.0	92.0	91.0	90.0
成员	taojianwen	tangpeng	wanglin	luokaocong

从到 -1 就是全部

Java操作

    @Test
    public void zRangeAndZRevRange() {
        String redisKey = "zSet7";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 返回有序集中指定区间的成员
        Set<Object> range = redisTemplate.opsForZSet().range(redisKey, 0, -1);
        log.info("有序集中指定区间的成员(分值升序)：{}", range);
        Set<Object> range2 = redisTemplate.opsForZSet().reverseRange(redisKey, 0, -1);
        log.info("有序集中指定区间的成员(分值降序)：{}", range2);
    }

有序集中指定区间的成员(分值升序)：[luokaocong, wanglin, tangpeng, taojianwen]
有序集中指定区间的成员(分值降序)：[taojianwen, tangpeng, wanglin, luokaocong]

2.8、ZRANGEBYSCORE、ZREVRANGEBYSCORE

ZRANGEBYSCORE 通过分数返回有序集合指定区间内的成员
ZREVRANGEBYSCORE 返回有序集中指定分数区间内的成员，分数从高到低排序

语法

ZRANGEBYSCORE KEY_NAME min max [WITHSCORES] [LIMIT offset count]
ZREVRANGEBYSCORE KEY_NAME max min [WITHSCORES] [LIMIT offset count]

命令操作

127.0.0.1:6379> zadd zset8 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zrangebyscore zset8 91 92 WITHSCORES
1) "wanglin"
2) "91"
3) "tangpeng"
4) "92"
127.0.0.1:6379> zrevrangebyscore zset8 92 91 WITHSCORES
1) "tangpeng"
2) "92"
3) "wanglin"
4) "91"

#查全部
127.0.0.1:6379> zrangebyscore zset8 -INF +INF WITHSCORES
1) "luokaocong"
2) "90"
3) "wanglin"
4) "91"
5) "tangpeng"
6) "92"
7) "taojianwen"
8) "95"
#查大于91小于等于95的
127.0.0.1:6379> zrangebyscore zset8 (91 95 WITHSCORES
1) "tangpeng"
2) "92"
3) "taojianwen"
4) "95"

Java操作

    @Test
    public void zRangeBySoreAndZRevRangeBySore() {
        String redisKey = "zSet8";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 通过分数返回有序集合指定区间内的成员
        Set<Object> range = redisTemplate.opsForZSet().rangeByScore(redisKey, 91.0, 92.0);
        log.info("通过分数返回有序集合指定区间内的成员(分值升序)：{}", range);
        Set<Object> range2 = redisTemplate.opsForZSet().reverseRangeByScore(redisKey, 91.0, 92.0);
        log.info("通过分数返回有序集合指定区间内的成员(分值降序)：{}", range2);
    }

通过分数返回有序集合指定区间内的成员(分值升序)：[wanglin, tangpeng]
通过分数返回有序集合指定区间内的成员(分值降序)：[tangpeng, wanglin]

2.9、ZCOUNT

ZCOUNT 计算在有序集合中指定区间分数的成员数

语法

ZCOUNT KEY_NAME min max

命令操作

127.0.0.1:6379> zadd zset9 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zcount zset9 91 92
(integer) 2
127.0.0.1:6379> zcount zset9 90 95
(integer) 4

向集合（zset9）中加入多个成员：taojianwen、tangpeng、wanglin、luokaocong
集合（zset9）中分数在 91 到 92 范围的成员有：2个
集合（zset9）中分数在 90 到 95 范围的成员有：4个

Java操作

    @Test
    public void zCount() {
        String redisKey = "zSet9";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 返回指定区间分数的成员数
        Long count = redisTemplate.opsForZSet().count(redisKey, 91.0, 92.0);
        log.info("返回指定区间分数的成员数：{}", count);
        Long count2 = redisTemplate.opsForZSet().count(redisKey, 90.0, 95.0);
        log.info("返回指定区间分数的成员数：{}", count2);
    }

返回指定区间分数的成员数：2
返回指定区间分数的成员数：4

2.10、ZREMRANGEBYRANK

ZREMRANGEBYRANK 移除有序集合中给定的排名区间的所有成员

语法

ZREMRANGEBYRANK KEY_NAME start stop

命令操作

127.0.0.1:6379> zadd zset10 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zremrangebyrank zset10 1 2
(integer) 2
127.0.0.1:6379> zrange zset10 0 -1 withscores
1) "luokaocong"
2) "90"
3) "taojianwen"
4) "95"

向集合（zset10）中加入多个成员：taojianwen、tangpeng、wanglin、luokaocong
集合（zset10）中移除排名从 1 到 2 的成员有：2个

Java操作

    @Test
    public void zRemRangeByRank() {
        String redisKey = "zSet10";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 移除有序集合中给定的排名区间的所有成员
        Long num = redisTemplate.opsForZSet().removeRange(redisKey, 1, 2);
        log.info("移除的成员数：{}", num);
        // 获取成员的信息
        Set<Object> range = redisTemplate.opsForZSet().range(redisKey, 0, -1);
        log.info("获取集合的信息：{}", range);
    }

移除的成员数：2
获取集合的信息：[luokaocong, taojianwen]

2.11、ZREMRANGEBYSCORE

ZREMRANGEBYSCORE 移除有序集合中给定的分数区间的所有成员

语法

ZREMRANGEBYSCORE KEY_NAME min max

命令操作

127.0.0.1:6379> zadd zset11 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zremrangebyscore zset11 91 96
(integer) 3
127.0.0.1:6379> zrange zset11 0 -1 withscores
1) "luokaocong"
2) "90"

向集合（zset11）中加入多个成员：taojianwen、tangpeng、wanglin、luokaocong
集合（zset11）中移除分数在 91 到 96 的成员
集合（zset11）只剩余一个成员 luokaocong

Java操作

    @Test
    public void zRemRangeByScore() {
        String redisKey = "zSet11";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple=new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey,tuple);
        // 移除有序集合中给定的分数区间的所有成员
        Long num  = redisTemplate.opsForZSet().removeRangeByScore(redisKey, 91, 96);
        log.info("移除的成员数：{}", num);
        // 获取成员的信息
        Set<Object> range = redisTemplate.opsForZSet().range(redisKey, 0, -1);
        log.info("获取集合的信息：{}", range);
    }

移除的成员数：3
获取集合的信息：[luokaocong]

2.12、ZINTERSTORE、ZUNIONSTORE

ZINTERSTORE 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 destination 中
ZUNIONSTORE 计算给定的一个或多个有序集的并集，并存储在新集合 destination 中

语法

ZINTERSTORE destination numkeys key [key ...]
ZUNIONSTORE destination numkeys key [key ...]

命令操作

127.0.0.1:6379> zadd zset12 95.0 taojianwen 92.0 tangpeng 91.0 wanglin
(integer) 3
127.0.0.1:6379> zadd zset13 88.0 tangpeng 80.0 wanglin
(integer) 2
127.0.0.1:6379> zinterstore interStore 2 zset12 zset13
(integer) 2
127.0.0.1:6379> zrange interStore 0 -1 withscores
1) "wanglin"
2) "171"
3) "tangpeng"
4) "180"
127.0.0.1:6379> zunionstore unionStore 2 zset12 zset13
(integer) 3
127.0.0.1:6379> zrange unionStore 0 -1 withscores
1) "taojianwen"
2) "95"
3) "wanglin"
4) "171"
5) "tangpeng"
6) "180"

Java操作

    @Test
    public void zInterStoreAndZUnionStore() {
        String redisKey = "zSet12";
        String redisKey1 = "zSet13";
        redisTemplate.delete(redisKey);
        redisTemplate.delete(redisKey1);

        redisTemplate.opsForZSet().add(redisKey,"taojianwen", 95.0);
        redisTemplate.opsForZSet().add(redisKey,"tangpeng", 92.0);
        redisTemplate.opsForZSet().add(redisKey,"wanglin", 91.0);

        redisTemplate.opsForZSet().add(redisKey1,"tangpeng", 88.0);
        redisTemplate.opsForZSet().add(redisKey1,"wanglin", 80.0);

        // 计算给定的一个或多个有序集的交集，存储到集合interStore
        Long num  = redisTemplate.opsForZSet().intersectAndStore(redisKey, redisKey1, "interStore");
        log.info("交集的成员数：{}", num);
        // 获取成员的信息
        Set<Object> range = redisTemplate.opsForZSet().range("interStore", 0, -1);
        log.info("获取集合的信息：{}", range);

        // 计算给定的一个或多个有序集的并集，存储到集合unionStore
        Long num1  = redisTemplate.opsForZSet().unionAndStore(redisKey, redisKey1, "unionStore");
        log.info("并集的成员数：{}", num1);
        // 获取成员的信息
        Set<Object> range1 = redisTemplate.opsForZSet().range("unionStore", 0, -1);
        log.info("获取集合的信息：{}", range1);
    }

交集的成员数：2
获取集合的信息：[wanglin, tangpeng]
并集的成员数：3
获取集合的信息：[taojianwen, wanglin, tangpeng]

2.13、ZRANGEBYLEX、ZREVRANGEBYLEX

ZRANGEBYLEX 获取字典序指定范围内的成员
ZREVRANGEBYLEX 逆序返回有序集合中指定范围内的成员

语法

ZRANGEBYLEX KEY_NAME min max
ZREVRANGEBYLEX KEY_NAME max min

命令操作

127.0.0.1:6379> zadd zset14 100 aa 100 ab 100 bb 100 bc 100 cc 100 cd 100 dd
(integer) 7
127.0.0.1:6379> zrangebylex zset14 - +
1) "aa"
2) "ab"
3) "bb"
4) "bc"
5) "cc"
6) "cd"
7) "dd"
127.0.0.1:6379> zrangebylex zset14 (bb [cd
1) "bc"
2) "cc"
3) "cd"
127.0.0.1:6379> zrevrangebylex zset14 [cd (bb
1) "cd"
2) "cc"
3) "bc"

集合（zset14）中加入了7个成员
查询集合（zset14）中所有的成员，最小值和最大值分别为 - 和 +
查询集合（zset14）中以 bb 开始，但是不包含 bb ，并且以 cd 结束的，但是包含 cd 的成员，这里的 ( 就类似于大于， [ 就类似于小于等于

Java操作

    @Test
    public void zRangeByLexAndZRevRangeByLex() {
        String redisKey = "zSet14";
        redisTemplate.delete(redisKey);

        redisTemplate.opsForZSet().add(redisKey, "aa", 100);
        redisTemplate.opsForZSet().add(redisKey, "ab", 100);
        redisTemplate.opsForZSet().add(redisKey, "bb", 100);
        redisTemplate.opsForZSet().add(redisKey, "bc", 100);
        redisTemplate.opsForZSet().add(redisKey, "cc", 100);
        redisTemplate.opsForZSet().add(redisKey, "cd", 100);
        redisTemplate.opsForZSet().add(redisKey, "dd", 100);

        RedisZSetCommands.Range range = new RedisZSetCommands.Range();
        range.gt("bb");
        range.lte("cd");
        // 字典序指定范围内的成员
        Set<Object> set1 = redisTemplate.opsForZSet().rangeByLex(redisKey, range);
        log.info("字典序指定范围内的成员：{}", set1);
        Set<Object> set2 = redisTemplate.opsForZSet().reverseRangeByLex(redisKey, range);
        log.info("字典序指定范围内的成员：{}", set2);
    }

结果未生效，官方文档说明暂不支持该命令

在这里插入图片描述

2.14、ZLEXCOUNT

ZLEXCOUNT 在有序集合中计算指定字典区间内成员数量

语法

ZLEXCOUNT KEY_NAME MIN MAX

命令操作

127.0.0.1:6379> zadd zset15 100 aa 100 ab 100 bb 100 bc 100 cc 100 cd 100 dd
(integer) 7
127.0.0.1:6379> zlexcount zset15 (bb [cd
(integer) 3

Java操作

    @Test
    public void zLexCount() {
        String redisKey = "zSet15";
        redisTemplate.delete(redisKey);

        redisTemplate.opsForZSet().add(redisKey, "aa", 100);
        redisTemplate.opsForZSet().add(redisKey, "ab", 100);
        redisTemplate.opsForZSet().add(redisKey, "bb", 100);
        redisTemplate.opsForZSet().add(redisKey, "bc", 100);
        redisTemplate.opsForZSet().add(redisKey, "cc", 100);
        redisTemplate.opsForZSet().add(redisKey, "cd", 100);
        redisTemplate.opsForZSet().add(redisKey, "dd", 100);

        RedisZSetCommands.Range range = new RedisZSetCommands.Range();
        range.gt("bb");
        range.lte("cd");
        // 计算指定字典区间内成员数量
        Long count = redisTemplate.opsForZSet().lexCount(redisKey, range);
        log.info("计算指定字典区间内成员数量：{}", count);
    }

结果未生效，官方文档说明暂不支持该命令（见上图）

2.15、ZREMRANGEBYLEX

ZREMRANGEBYLEX 移除有序集合中给定的字典区间的所有成员

语法

ZREMRANGEBYLEX KEY_NAME min max

命令操作

127.0.0.1:6379> zadd zset16 100 aa 100 ab 100 bb 100 bc 100 cc 100 cd 100 dd
(integer) 7
127.0.0.1:6379> zremrangebylex zset16 (bb [cd
(integer) 3
127.0.0.1:6379> zrange zset16 0 -1 withscores
1) "aa"
2) "100"
3) "ab"
4) "100"
5) "bb"
6) "100"
7) "dd"
8) "100"

Java操作

    @Test
    public void zRemRangeByLex() {
        String redisKey = "zSet16";
        redisTemplate.delete(redisKey);

        redisTemplate.opsForZSet().add(redisKey, "aa", 100);
        redisTemplate.opsForZSet().add(redisKey, "ab", 100);
        redisTemplate.opsForZSet().add(redisKey, "bb", 100);
        redisTemplate.opsForZSet().add(redisKey, "bc", 100);
        redisTemplate.opsForZSet().add(redisKey, "cc", 100);
        redisTemplate.opsForZSet().add(redisKey, "cd", 100);
        redisTemplate.opsForZSet().add(redisKey, "dd", 100);

        RedisZSetCommands.Range range = new RedisZSetCommands.Range();
        range.gt("bb");
        range.lte("cd");
        // 移除有序集合中给定的字典区间的所有成员
        Long count = redisTemplate.opsForZSet().removeRangeByLex(redisKey, range);
        log.info("移除有序集合中给定的字典区间的所有成员：{}", count);
    }

结果未生效，官方文档说明暂不支持该命令（见上图）

2.16、ZPOPMAX、ZPOPMIN

ZPOPMAX 弹出分数最高的成员
ZPOPMIN 弹出分数最低的成员

语法

ZPOPMAX KEY_NAME [COUNT]
ZPOPMIN KEY_NAME [COUNT]

命令操作

127.0.0.1:6379> zadd zset17 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> zpopmax zset17 2
1) "taojianwen"
2) "95"
3) "tangpeng"
4) "92"
127.0.0.1:6379> zpopmin zset17 2
1) "luokaocong"
2) "90"
3) "wanglin"
4) "91"

向集合（zset17）中加入多个成员：taojianwen、tangpeng、wanglin、luokaocong
弹出集合（zset17）中分数最高的两个成员，弹出了 taojianwen 到 tangpeng
弹出集合（zset17）中分数最低的两个成员，弹出了 luokaocong到 wanglin

Java操作

    @Test
    public void zPopMaXAndZPopMin() {
        String redisKey = "zSet17";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple = new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey, tuple);
        // 弹出分数最高的两个成员
        Set<ZSetOperations.TypedTuple<Object>> typedTuples1 = redisTemplate.opsForZSet().popMax(redisKey, 2);
        log.info("弹出分数最高的两个成员：{}", typedTuples1);
        // 弹出分数最低的两个成员
        Set<ZSetOperations.TypedTuple<Object>> typedTuples2 = redisTemplate.opsForZSet().popMin(redisKey, 2);
        log.info("弹出分数最低的两个成员：{}", typedTuples2);
    }

弹出分数最高的两个成员：[DefaultTypedTuple [score=95.0, value=taojianwen], DefaultTypedTuple [score=92.0, value=tangpeng]]
弹出分数最低的两个成员：[DefaultTypedTuple [score=90.0, value=luokaocong], DefaultTypedTuple [score=91.0, value=wanglin]]

2.17、BZPOPMAX、BZPOPMIN

BZPOPMAX 阻塞式弹出分数最高的成员
BZPOPMIN 阻塞式弹出分数最低的成员

语法

命令操作

127.0.0.1:6379> zadd zset18 95.0 taojianwen 92.0 tangpeng 91.0 wanglin 90.0 luokaocong
(integer) 4
127.0.0.1:6379> bzpopmax zset18 10
1) "zset18"
2) "taojianwen"
3) "95"
127.0.0.1:6379> bzpopmin zset18 10
1) "zset18"
2) "luokaocong"
3) "90"

Java操作

    @Test
    public void zBPopMaXAndZBPopMin() {
        String redisKey = "zSet18";
        redisTemplate.delete(redisKey);
        // 添加多个成员
        Set<ZSetOperations.TypedTuple<Object>> tuple = new HashSet<>();
        tuple.add(new DefaultTypedTuple<>("taojianwen", 95.0));
        tuple.add(new DefaultTypedTuple<>("tangpeng", 92.0));
        tuple.add(new DefaultTypedTuple<>("wanglin", 91.0));
        tuple.add(new DefaultTypedTuple<>("luokaocong", 90.0));
        redisTemplate.opsForZSet().add(redisKey, tuple);
        // 阻塞式弹出分数最高的成员，如果没有，则直到超时
        ZSetOperations.TypedTuple<Object> objectTypedTuple = redisTemplate.opsForZSet().popMax(redisKey, 10, TimeUnit.SECONDS);
        log.info("弹出分数最高的成员：{}", objectTypedTuple);
        // 阻塞式弹出分数最低的成员，如果没有，则直到超时
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = redisTemplate.opsForZSet().popMin(redisKey, 10, TimeUnit.SECONDS);
        log.info("弹出分数最低的成员：{}", objectTypedTuple2);
    }

弹出分数最高的成员：DefaultTypedTuple [score=95.0, value=taojianwen]
弹出分数最低的成员：DefaultTypedTuple [score=90.0, value=luokaocong]