RedisTemplate访问Redis数据结构（四）——Set

https://blog.youkuaiyun.com/weixin_37490221/article/details/78135202

引用：Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据，Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。此处我们使用redisTemplate，配置如下（详情请见链接：RedisTemplate访问Redis数据结构（前言））

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">  
    <property name="connectionFactory" ref="jedisConnFactory"/>  
    <property name="keySerializer">
        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    </property>
    <property name="hashKeySerializer">
        <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    </property>
    <property name="valueSerializer">
        <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
    </property>
    <property name="hashValueSerializer">
        <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
    </property>
</bean> 

SetOperations提供了对无序集合的一系列操作。首先初始化spring工厂获得redisTemplate和opsForSet

    private RedisTemplate<String,Object> redisTemplate;
    private SetOperations<String, Object> opsForSet;

    @SuppressWarnings("unchecked")
    @Before
    public void before(){
        @SuppressWarnings("resource")
        ApplicationContext context = new ClassPathXmlApplicationContext("/applicationContext.xml");
        redisTemplate = (RedisTemplate<String,Object>)context.getBean("redisTemplate");
        opsForSet = redisTemplate.opsForSet();
    }

Long add(K key, V… values);

Long size(K key);

Set< V > members(K key);

    @Test
    public void testAddSizeAndMembers(){
        redisTemplate.delete("zhou1");
        //无序集合中添加元素，返回添加个数 也可以直接在add里面添加多个值
        System.out.println(opsForSet.add("zhou1", "a"));//1
        //无序集合的大小长度
        System.out.println(opsForSet.size("zhou1"));//1
        System.out.println(opsForSet.add("zhou1", "a","b","c","d","e"));//4
        System.out.println(opsForSet.size("zhou1"));//5
        System.out.println(opsForSet.add("zhou1", new Object[]{"f","g"}));//4
        System.out.println(opsForSet.size("zhou1"));//7
        //返回集合中的所有成员
        System.out.println(opsForSet.members("zhou1"));//[f, g, d, a, e, b, c]
    }

Long remove(K key, Object… values);

    @Test
    public void testRemove(){
        redisTemplate.delete("zhou2");
        User user = new User();
        user.setId(1l);
        opsForSet.add("zhou2", "a","b","c","d","e",user);
        User user1 = new User();
        //移除集合中一个或多个成员
        System.out.println(opsForSet.remove("zhou2", "a","d","f",user1));//2
        System.out.println(opsForSet.members("zhou2"));//[e, b, c]
    }

V pop(K key);

    @Test
    public void testPop(){
        redisTemplate.delete("zhou3");
        opsForSet.add("zhou3", "a","b","c","d","e");
        //移除并返回集合中的一个随机元素
        System.out.println(opsForSet.pop("zhou3"));//e
        System.out.println(opsForSet.members("zhou3"));//[d, a, b, c]
    }

Boolean move(K key, V value, K destKey);

    @Test
    public void testMove(){
        redisTemplate.delete("zhou4");
        redisTemplate.delete("zhou5");
        opsForSet.add("zhou4", "a","b");
        //将 member 元素从 source 集合移动到 destination 集合
        System.out.println(opsForSet.move("zhou4", "a", "zhou4"));//true
        System.out.println(opsForSet.move("zhou4", "c", "zhou5"));//false
        System.out.println(opsForSet.move("zhou4", "a", "zhou5"));//true
        opsForSet.add("zhou5", "b");
        System.out.println(opsForSet.move("zhou4", "b", "zhou5"));//true
    }

Boolean isMember(K key, Object o);

    @Test
    public void testIsMember(){
        //判断 member 元素是否是集合 key 的成员
        System.out.println(opsForSet.isMember("zhou6", "a"));//false
    }

Set< V > intersect(K key, K otherKey);

Set< V > intersect(K key, Collection< K > otherKeys);

Long intersectAndStore(K key, K otherKey, K destKey);

Long intersectAndStore(K key, Collection< K > otherKeys, K destKey);

    @Test
    public void testIntersect(){
        redisTemplate.delete("zhou7");
        redisTemplate.delete("zhou8");
        redisTemplate.delete("zhou9");
        redisTemplate.delete("zhou10");
        redisTemplate.delete("zhou11");
        opsForSet.add("zhou7", "a","b","c","d","e");
        opsForSet.add("zhou8", "c","d","e","f","g");
        //key对应的无序集合与otherKey对应的无序集合求交集
        Set<Object> intersect = opsForSet.intersect("zhou7", "zhou8");
        System.out.println(intersect);//[d, c, e]
        opsForSet.add("zhou9", "c","h");
        //key对应的无序集合与多个otherKey对应的无序集合求交集
        System.out.println(opsForSet.intersect("zhou7", Arrays.asList("zhou8","zhou9")));//[c]
        //key无序集合与otherkey无序集合的交集存储到destKey无序集合中
        System.out.println(opsForSet.intersectAndStore("zhou7", "zhou8","zhou10"));//3
        System.out.println(opsForSet.members("zhou10"));//[e, c, d]
        //key对应的无序集合与多个otherKey对应的无序集合求交集存储到destKey无序集合中
        System.out.println(opsForSet.intersectAndStore("zhou7", Arrays.asList("zhou8","zhou9"),"zhou11"));//1
        System.out.println(opsForSet.members("zhou11"));//[c]
    }

Set< V > union(K key, K otherKey);

Set< V > union(K key, Collection< K > otherKeys);

Long unionAndStore(K key, K otherKey, K destKey);

Long unionAndStore(K key, Collection otherKeys, K destKey);

    @Test
    public void testUnion(){
        redisTemplate.delete("zhou12");
        redisTemplate.delete("zhou13");
        redisTemplate.delete("zhou14");
        redisTemplate.delete("zhou15");
        redisTemplate.delete("zhou16");
        opsForSet.add("zhou12", "a","b","c","d","e");
        opsForSet.add("zhou13", "c","d","e","f","g");
        //key无序集合与otherKey无序集合的并集
        Set<Object> union = opsForSet.union("zhou12", "zhou13");
        System.out.println(union);//[f, g, d, a, e, c, b]
        opsForSet.add("zhou14", "c","h");
        //key无序集合与多个otherKey无序集合的并集
        System.out.println(opsForSet.union("zhou12", Arrays.asList("zhou13","zhou14")));//[h, f, g, d, a, e, c, b]
        //key无序集合与otherkey无序集合的并集存储到destKey无序集合中
        System.out.println(opsForSet.unionAndStore("zhou12", "zhou13","zhou15"));//7
        System.out.println(opsForSet.members("zhou15"));//[f, g, d, a, e, c, b]
        //key无序集合与多个otherkey无序集合的并集存储到destKey无序集合中
        System.out.println(opsForSet.unionAndStore("zhou12", Arrays.asList("zhou13","zhou14"),"zhou16"));//8
        System.out.println(opsForSet.members("zhou16"));//[h, f, g, d, a, e, c, b]
    }

Set difference(K key, K otherKey);

Set difference(K key, Collection otherKeys);

Long differenceAndStore(K key, K otherKey, K destKey);

Long differenceAndStore(K key, Collection otherKeys, K destKey);

    @Test
    public void testDifference(){
        redisTemplate.delete("zhou17");
        redisTemplate.delete("zhou18");
        redisTemplate.delete("zhou19");
        redisTemplate.delete("zhou20");
        redisTemplate.delete("zhou21");
        opsForSet.add("zhou17", "a","b","c","d","e");
        opsForSet.add("zhou18", "c","d","e","f","g");
        //key无序集合与otherKey无序集合的差集
        Set<Object> difference = opsForSet.difference("zhou17", "zhou18");
        System.out.println(difference);//[a, b]
        opsForSet.add("zhou19", "c","h");
        //key无序集合与多个otherKey无序集合的差集
        System.out.println(opsForSet.difference("zhou17", Arrays.asList("zhou18","zhou19")));//[a, b]
        //key无序集合与otherkey无序集合的差集存储到destKey无序集合中
        System.out.println(opsForSet.differenceAndStore("zhou17", "zhou18","zhou20"));//2
        System.out.println(opsForSet.members("zhou20"));//[a, b]
        //key无序集合与多个otherkey无序集合的差集存储到destKey无序集合中
        System.out.println(opsForSet.differenceAndStore("zhou17", Arrays.asList("zhou18","zhou19"),"zhou21"));//2
        System.out.println(opsForSet.members("zhou21"));//[a, b]
    }

V randomMember(K key);

    @Test
    public void testRandomMember(){
        redisTemplate.delete("zhou22");
        opsForSet.add("zhou22", "a","b","c","d","e");
        //随机获取key无序集合中的一个元素
        System.out.println(opsForSet.randomMember("zhou22"));//e
        System.out.println(opsForSet.randomMember("zhou22"));//d
        System.out.println(opsForSet.randomMember("zhou22"));//c
        System.out.println(opsForSet.randomMember("zhou22"));//b
        System.out.println(opsForSet.randomMember("zhou22"));//e
        //获取多个key无序集合中的元素，count表示个数
        System.out.println(opsForSet.randomMembers("zhou22",8));//[e, a, e, e, d, e, b, e]
        System.out.println(opsForSet.randomMembers("zhou22",4));//[d, c, d, d]
        //获取多个key无序集合中的元素（去重），count表示个数
        System.out.println(opsForSet.distinctRandomMembers("zhou22",6));//[c, e, d, a, b]
        System.out.println(opsForSet.distinctRandomMembers("zhou22",4));//c, b, e, d]
    }

Cursor scan(K key, ScanOptions options);

    @Test
    public void testScan(){
        redisTemplate.delete("zhou23");
        opsForSet.add("zhou23", "a","b","c","d","e");
        //遍历set,类似于Interator
        Cursor<Object> curosr = opsForSet.scan("zhou23", ScanOptions.NONE);
        while(curosr.hasNext()){
            System.out.println(curosr.next());//e a d c b
        }
    }