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

时间：2025-02-18 09:16:37

目录

    • 一、简介
    • 二、常用方法
      • 2.1、SADD
      • 2.2、SREM
      • 2.3、SMOVE
      • 2.4、SMEMBERS
      • 2.5、SCARD
      • 2.6、SISMEMBER
      • 2.7、SRANDMEMBER
      • 2.8、SPOP
      • 2.9、SINTER
      • 2.10、SINTERSTORE
      • 2.11、SUNION
      • 2.12、SUNIONSTORE
      • 2.13、SDIFF
      • 2.14、SDIFFSTORE

一、简介

  本文今天主要是集合（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 RedisSetTest {

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

二、常用方法

2.1、SADD

  • SADD 向集合添加一个或多个成员

语法

SADD KEY_NAME VALUE1..VALUEn

命令操作

127.0.0.1:6379> sadd set1 apple
(integer) 1
127.0.0.1:6379> sadd set1 banana pear
(integer) 2
127.0.0.1:6379> smembers set1
1) "banana"
2) "apple"
3) "pear"
  • 向集合（set1）中加入：apple
  • 向集合（set1）中加入：banana、pear
  • 此时集合（set1）的元素：banana、apple、pear

Java操作

    @Test
    public void sAdd() {
        String redisKey = "set1";
        redisTemplate.delete(redisKey);
        // 添加一种水果
        redisTemplate.opsForSet().add(redisKey, "apple");
        // 添加两种水果
        redisTemplate.opsForSet().add(redisKey, "banana","pear");
        // 获取集合的信息
        Set<Object> members = redisTemplate.opsForSet().members(redisKey);
        log.info("获取集合的信息：{}", members);
    }

获取集合的信息：[banana, apple, pear]

2.2、SREM

  • SREM 移除集合中一个或多个成员

语法

SREM KEY_NAME MEMBER1..MEMBERn

命令操作

127.0.0.1:6379> sadd set2 "apple" "banana" "pear" "orange"
(integer) 4
127.0.0.1:6379> srem set2 apple
(integer) 1
127.0.0.1:6379> srem set2 banana pear
(integer) 2
127.0.0.1:6379> smembers set2
1) "orange"
  • 先初始化一个集合（set2）得到：apple、banana、pear、orange
  • 从集合（set2）移除 apple
  • 从集合（set2）移除banana、pear
  • 此时集合（set2）的元素：orange

Java操作

    @Test
    public void sRem() {
        String redisKey = "set2";
        redisTemplate.delete(redisKey);
        // 添加多种水果
        redisTemplate.opsForSet().add(redisKey, "apple", "banana", "pear", "orange");
        redisTemplate.opsForSet().remove(redisKey, "apple");
        redisTemplate.opsForSet().remove(redisKey, "banana", "pear");
        // 获取集合的信息
        Set<Object> members = redisTemplate.opsForSet().members(redisKey);
        log.info("获取集合的信息：{}", members);
    }

获取集合的信息：[orange]

2.3、SMOVE

  • SMOVE 将 member 元素从 source 集合移动到 目标集合destination

语法

SMOVE SOURCE_KEY_NAME DESTINATION_KEY_NAME MEMBER

命令操作

127.0.0.1:6379> sadd set3 "apple" "banana" "pear"
(integer) 3
127.0.0.1:6379> sadd setDes orange
(integer) 1
127.0.0.1:6379> smove set3 setDes pear
(integer) 1
127.0.0.1:6379> smembers set3
1) "banana"
2) "apple"
127.0.0.1:6379> smembers setDes
1) "orange"
2) "pear"
  • 先初始化一个集合（set3）得到：apple、banana、pear
  • 先初始化一个集合（setDes）得到：orange
  • 从集合（set3）移动一个元素 pear到集合（setDes）
  • 此时集合（set3）的元素：apple、banana
  • 此时集合（setDes）的元素：orange、pear

Java操作

    @Test
    public void sMove() {
        String redisKey = "set3";
        redisTemplate.delete(redisKey);
        // 添加多种水果
        redisTemplate.opsForSet().add(redisKey, "apple", "banana", "pear");
        redisTemplate.opsForSet().add("setDes", "orange");
        redisTemplate.opsForSet().move(redisKey, "pear","setDes");
        // 获取集合的信息
        Set<Object> set3 = redisTemplate.opsForSet().members(redisKey);
        log.info("获取集合set3的信息：{}", set3);
        Set<Object> setDes = redisTemplate.opsForSet().members("setDes");
        log.info("获取集合setDes的信息：{}", setDes);
    }

获取集合set3的信息：[banana, apple]
获取集合setDes的信息：[orange, pear]

2.4、SMEMBERS

  • SMEMBERS 返回集合中的所有成员

语法

SMEMBERS KEY_NAME

命令操作

127.0.0.1:6379> sadd set4 "apple" "banana" "pear" "orange"
(integer) 4
127.0.0.1:6379> smembers set4
1) "orange"
2) "banana"
3) "apple"
4) "pear"
  • 先初始化一个集合（set4）得到：apple、banana、pear、orange
  • 此时集合（set4）的元素：banana、orange、apple、pear

Java操作

    @Test
    public void sMembers() {
        String redisKey = "set4";
        redisTemplate.delete(redisKey);
        // 添加多种水果
        redisTemplate.opsForSet().add(redisKey, "apple", "banana", "pear","orange");
        // 获取集合的信息
        Set<Object> set4 = redisTemplate.opsForSet().members(redisKey);
        log.info("获取集合set4的信息：{}", set4);
    }

获取集合set4的信息：[banana, orange, apple, pear]

2.5、SCARD

  • SCARD 获取集合的成员数

语法

SCARD KEY_NAME

命令操作

127.0.0.1:6379> sadd set5 "apple" "banana" "pear" "orange"
(integer) 4
127.0.0.1:6379> smembers set5
1) "orange"
2) "banana"
3) "apple"
4) "pear"
127.0.0.1:6379> scard set5
(integer) 4
  • 先初始化一个集合（set5）得到：apple、banana、pear、orange
  • 此时集合（set5）的元素个数：4

Java操作

    @Test
    public void sCard() {
        String redisKey = "set5";
        redisTemplate.delete(redisKey);
        // 添加多种水果
        redisTemplate.opsForSet().add(redisKey, "apple", "banana", "pear","orange");
        // 获取集合的信息
        Set<Object> set5 = redisTemplate.opsForSet().members(redisKey);
        log.info("获取集合的信息：{}", set5);
        Long size = redisTemplate.opsForSet().size(redisKey);
        log.info("获取集合的成员的个数：{}", size);
    }

获取集合的信息：[banana, orange, apple, pear]
获取集合的成员的个数：4

2.6、SISMEMBER

  • SISMEMBER 判断 member 元素是否是集合 key 的成员

语法

SISMEMBER KEY_NAME VALUE

命令操作

127.0.0.1:6379> sadd set6 "apple" "banana" "pear" "orange"
(integer) 4
127.0.0.1:6379> sismember set6 strawberry
(integer) 0
  • 先初始化一个集合（set6）得到：apple、banana、pear、orange
  • 判断元素strawberry是否是（set6）的一个成员，得到 0，也就是false

Java操作

    @Test
    public void sIsMember() {
        String redisKey = "set6";
        redisTemplate.delete(redisKey);
        // 添加多种水果
        redisTemplate.opsForSet().add(redisKey, "apple", "banana", "pear","orange");
        // 判断strawberry是否是集合的一个元素
        Boolean isMember = redisTemplate.opsForSet().isMember(redisKey, "strawberry");
        log.info("判断strawberry是否是集合的一个元素：{}", isMember);
    }

判断strawberry是否是集合的一个元素：false

2.7、SRANDMEMBER

  • SRANDMEMBER 返回集合中一个或多个随机数

语法

SRANDMEMBER KEY_NAME [COUNT]

命令操作

127.0.0.1:6379> sadd set7 "apple" "banana" "pear" "orange"
(integer) 4
127.0.0.1:6379> srandmember set7
"orange"
127.0.0.1:6379> srandmember set7 2
1) "orange"
2) "banana"
  • 先初始化一个集合（set7）得到：apple、banana、pear、orange
  • 随机从集合（set7）获取一个元素，得到orange
  • 随机从集合（set7）获取两个元素，得到orange、banana

Java操作

    @Test
    public void sRandMember() {
        String redisKey = "set7";
        redisTemplate.delete(redisKey);
        // 添加多种水果
        redisTemplate.opsForSet().add(redisKey, "apple", "banana", "pear","orange");
        // 随机从集合中获取一个元素
        Object member = redisTemplate.opsForSet().randomMember(redisKey);
        log.info("随机从集合中获取到的元素：{}", member);
        // 随机从集合中获取多个元素
        List<Object> list = redisTemplate.opsForSet().randomMembers(redisKey, 2);
        log.info("随机从集合中获取多个元素：{}", list);
    }

随机从集合中获取到的元素：banana
随机从集合中获取多个元素：[orange, apple]

2.8、SPOP

  • SPOP 移除并返回集合中的一个随机元素

语法

SPOP KEY_NAME [COUNT]

命令操作

127.0.0.1:6379> sadd set8 "apple" "banana" "pear" "orange"
(integer) 4
127.0.0.1:6379> spop set8
"pear"
127.0.0.1:6379> smembers set8
1) "orange"
2) "banana"
3) "apple"
127.0.0.1:6379> spop set8 2
1) "banana"
2) "orange"
127.0.0.1:6379> smembers set8
1) "apple"
  • 先初始化一个集合（set8）得到：apple、banana、pear、orange
  • 随机从集合（set8）移除一个元素，得到pear
  • 此时集合（set8）的元素：apple、banana、orange
  • 随机从集合（set8）移除两个元素，得到banana、orange
  • 此时集合（set8）的元素：apple

Java操作

    @Test
    public void sPop() {
        String redisKey = "set8";
        redisTemplate.delete(redisKey);
        // 添加多种水果
        redisTemplate.opsForSet().add(redisKey, "apple", "banana", "pear","orange");
        // 随机从集合中移除一个元素
        Object member = redisTemplate.opsForSet().pop(redisKey);
        log.info("随机从集合中移除一个元素：{}", member);
        Set<Object> set8 = redisTemplate.opsForSet().members(redisKey);
        log.info("获取集合的信息：{}", set8);

        // 随机从集合中获取多个元素
        List<Object> list = redisTemplate.opsForSet().pop(redisKey, 2);
        log.info("随机从集合中移除多个元素：{}", list);
        set8 = redisTemplate.opsForSet().members(redisKey);
        log.info("获取集合的信息：{}", set8);
    }

随机从集合中移除一个元素：pear
获取集合的信息：[banana, orange, apple]
随机从集合中移除多个元素：[orange, banana]
获取集合的信息：[apple]

2.9、SINTER

  • SINTER 返回给定所有集合的交集

语法

SINTER KEY_NAME1 KEY_NAME2...KEY_NAMEn
SINTERSTORE DESTINATION_KEY KEY_NAME1 KEY_NAME2...KEY_NAMEn

命令操作

127.0.0.1:6379> sadd set9 "apple" "banana" "pear"
(integer) 3
127.0.0.1:6379> sadd set10 "apple" "banana" "orange"
(integer) 3
127.0.0.1:6379> sadd set11 "apple"
(integer) 1
127.0.0.1:6379> sinter set9 set10
1) "banana"
2) "apple"
127.0.0.1:6379> sinter set9 set10 set11
1) "apple"
  • 初始化一个集合（set9）得到：apple、banana、pear
  • 初始化一个集合（set10）得到：apple、banana、orange
  • 初始化一个集合（set11）得到：apple
  • 集合 set9 和 set10 的交集：apple、banana
  • 集合 set9、 set10 和 set11 的交集：apple

Java操作

    @Test
    public void sInter() {
        String redisKey = "set9";
        String redisKey2 = "set10";
        String redisKey3 = "set11";
        redisTemplate.delete(redisKey);
        redisTemplate.delete(redisKey2);
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey, "apple", "banana", "pear");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey2, "apple", "banana", "orange");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey3, "apple");
        // 两个集合的交集
        Set<Object> intersect = redisTemplate.opsForSet().intersect(redisKey, redisKey2);
        log.info("相同的元素为：{}", intersect);
        // 多个集合的交集
        Set<Object> inter = redisTemplate.opsForSet().intersect(redisKey, Arrays.asList(redisKey2, redisKey3));
        log.info("相同的元素为：{}", inter);
    }

相同的元素为：[banana, apple]
相同的元素为：[apple]

2.10、SINTERSTORE

  • SINTERSTORE 返回给定所有集合的交集并存储在 destination 中

语法

SINTERSTORE DESTINATION_KEY KEY_NAME1 KEY_NAME2...KEY_NAMEn

命令操作

127.0.0.1:6379> sadd set12 "apple" "banana" "pear"
(integer) 3
127.0.0.1:6379> sadd set13 "apple" "banana" "orange"
(integer) 3
127.0.0.1:6379> sadd set14 "apple"
(integer) 1
127.0.0.1:6379> sinterstore desKey set12 set13
(integer) 2
127.0.0.1:6379> smembers desKey
1) "apple"
2) "banana"
127.0.0.1:6379> sinterstore desKey2 set12 set13 set14
(integer) 1
127.0.0.1:6379> smembers desKey2
1) "apple"
  • 初始化一个集合（set12）得到：apple、banana、pear
  • 初始化一个集合（set13）得到：apple、banana、orange
  • 初始化一个集合（set14）得到：apple
  • 存储集合 set12 和 set13 的交集，查询得到：apple、banana
  • 存储集合 set12、 set13 和 set14 的交集，查询得到：apple

Java操作

    @Test
    public void sInterStore() {
        String redisKey = "set12";
        String redisKey2 = "set13";
        String redisKey3 = "set14";
        redisTemplate.delete(redisKey);
        redisTemplate.delete(redisKey2);
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey, "apple", "banana", "pear");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey2, "apple", "banana", "orange");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey3, "apple");
        // 存储两个集合的交集到desKey集合
        Long desKey = redisTemplate.opsForSet().intersectAndStore(redisKey, redisKey2, "desKey");
        log.info("存储两个集合的交集为：{}", desKey);
        // 存储多个集合的交集到desKey2集合
        Long desKey2 = redisTemplate.opsForSet().intersectAndStore(Arrays.asList(redisKey, redisKey2, redisKey3), "desKey2");
        log.info("存储多个集合的交集为：{}", desKey2);
    }

存储两个集合的交集个数：2
存储两个集合的交集为：[banana, apple]
存储多个集合的交集个数：1
存储多个集合的交集为：[apple]

2.11、SUNION

  • SUNION 返回所有给定集合的并集

语法

SUNION KEY_NAME KEY_NAME1...KEY_NAMEn

命令操作

127.0.0.1:6379> sadd set15 "apple" "banana"
(integer) 2
127.0.0.1:6379> sadd set16 "banana" "orange"
(integer) 2
127.0.0.1:6379> sunion set15 set16
1) "orange"
2) "apple"
3) "banana"
  • 初始化一个集合（set15）得到：apple、banana
  • 初始化一个集合（set16）得到：banana、orange
  • 集合 set15 和 set16 的并集为：apple、banana、orange（自动去重）

Java操作

    @Test
    public void sUnion() {
        String redisKey = "set15";
        String redisKey2 = "set16";
        redisTemplate.delete(redisKey);
        redisTemplate.delete(redisKey2);
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey, "apple", "banana");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey2,  "banana", "orange");
        // 存储两个集合的并集
        Set<Object> union = redisTemplate.opsForSet().union(redisKey, redisKey2);
        log.info("存储两个集合的并集：{}", union);
    }

存储两个集合的并集：[banana, orange, apple]

2.12、SUNIONSTORE

  • SUNIONSTORE 将

语法

SINTERSTORE DESTINATION_KEY KEY_NAME1 KEY_NAME2...KEY_NAMEn

命令操作

127.0.0.1:6379> sadd set17 "apple" "banana"
(integer) 2
127.0.0.1:6379> sadd set18 "banana" "orange"
(integer) 2
127.0.0.1:6379> sunionstore unionStore set17 set18
(integer) 3
127.0.0.1:6379> smembers unionStore
1) "orange"
2) "apple"
3) "banana"
  • 初始化一个集合（set17）得到：apple、banana
  • 初始化一个集合（set18）得到：banana、orange
  • 存储集合 set17 和 set18 的并集到集合 unionStore，个数为 3（自动去重）
  • 查询集合 unionStore 的元素，查询得到：apple、banana、orange

Java操作

    @Test
    public void sUnionStore() {
        String redisKey = "set17";
        String redisKey2 = "set18";
        redisTemplate.delete(redisKey);
        redisTemplate.delete(redisKey2);
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey, "apple", "banana");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey2,  "banana", "orange");
        // 存储两个集合的并集
        Long unionStore = redisTemplate.opsForSet().unionAndStore(redisKey, redisKey2, "unionStore");
        log.info("两个集合的并集的个数：{}", unionStore);
        Set<Object> unionStoreSet = redisTemplate.opsForSet().members("unionStore");
        log.info("存储多个集合的并集为：{}", unionStoreSet);
    }

两个集合的并集的个数：3
存储多个集合的并集为：[banana, orange, apple]

2.13、SDIFF

  • SDIFF 返回第一个集合与其他集合之间的差异

语法

SDIFF SOURCE_KEY_NAME OTHER_KEY_NAME1...OTHER_KEY_NAMEn

命令操作

127.0.0.1:6379> sadd set19 "apple" "banana" "pear"
(integer) 3
127.0.0.1:6379> sadd set20 "banana" "orange"
(integer) 2
127.0.0.1:6379> sadd set21 "apple"
(integer) 1
127.0.0.1:6379> sdiff set19 set20 set21
1) "pear"
  • 初始化一个集合（set19）得到：apple、banana、pear
  • 初始化一个集合（set20）得到：banana、orange
  • 初始化一个集合（set21）得到：apple
  • 集合 set19 、 set20 、 set21 的差集为 pear，实际就是用 set19 减去 set20 再减去 set21 得到的结果

Java操作

    @Test
    public void sDiff() {
        String redisKey = "set19";
        String redisKey2 = "set20";
        String redisKey3 = "set21";
        redisTemplate.delete(redisKey);
        redisTemplate.delete(redisKey2);
        redisTemplate.delete(redisKey3);
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey, "apple", "banana","pear");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey2,  "banana", "orange");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey2,  "apple");
        // 多个集合的差集
        Set<Object> difference = redisTemplate.opsForSet().difference(Arrays.asList(redisKey, redisKey2, redisKey3));
        log.info("多个集合的差集为：{}", difference);
    }

存储多个集合的差集为：[pear]

2.14、SDIFFSTORE

  • SDIFFSTORE 返回给定所有集合的差集并存储在 destination 中

语法

SDIFFSTORE DESTINATION_KEY_NAME KEY_NAME1...KEY_NAMEn

命令操作

127.0.0.1:6379> sadd set22 "apple" "banana" "pear"
(integer) 3
127.0.0.1:6379> sadd set23 "banana" "orange"
(integer) 2
127.0.0.1:6379> sadd set24 "apple"
(integer) 1
127.0.0.1:6379> sdiffstore difference set22 set23 set24
(integer) 1
127.0.0.1:6379> smembers difference
1) "pear"
  • 初始化一个集合（set22）得到：apple、banana、pear
  • 初始化一个集合（set23）得到：banana、orange
  • 初始化一个集合（set24）得到：apple
  • 存储集合 set22 、 set23 、 set24 的差集到集合 difference，实际就是用 set22 减去 set23 再减去 set24 ，然后把结果存储到集合 difference

Java操作

    @Test
    public void sDiffStore() {
        String redisKey = "set22";
        String redisKey2 = "set23";
        String redisKey3 = "set24";
        redisTemplate.delete(redisKey);
        redisTemplate.delete(redisKey2);
        redisTemplate.delete(redisKey3);
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey, "apple", "banana","pear");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey2,  "banana", "orange");
        // 初始化集合
        redisTemplate.opsForSet().add(redisKey3,  "apple");
        // 存储多个集合的差集
        Long difference = redisTemplate.opsForSet().differenceAndStore(redisKey,Arrays.asList(redisKey2, redisKey3), "difference");
        log.info("多个集合的差集个数：{}", difference);
        Set<Object> differenceSet = redisTemplate.opsForSet().members("difference");
        log.info("存储多个集合的差集为：{}", differenceSet);
    }

多个集合的差集个数：1
存储多个集合的差集为：[pear]

相关文章