【RedisTemplate】Set数据类型的常用操作

快来打我* 2022-12-15 03:36 494阅读 0赞

# 引言 #

###### 上篇博客总结了使用RedisTemplate操作ZSet数据类型的一些常用方法，本篇博客继续总结Set数据类型。 ######

# Set数据结构 #

###### Redis 的 Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。 ######

###### Redis 中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。 ######

# 常用方法 #

### 1. 增加集合元素 ###

/** * set中增加元素，支持一次增加多个元素，逗号分隔即可，结果返回添加的个数 * * @param key * @param value * @return */
    public Long addSet(String key, Object... value) { 
        Long size = null;
        try { 
            size = redisTemplate.opsForSet().add(key, value);
        } catch (Exception e) { 
            log.error("[RedisUtils.addSet] [error]", e);
            return size;
        }
        return size;
    }

###### 示例代码 ######

@Test
    public void addSet() { 
        System.out.println(redisUtils.addSet("word-book", "article", "boy", "cat", "dog", "English"));
        System.out.println(redisUtils.addSet("chinese-word", "年", "月", "日"));
    }

### 2. 移除指定元素 ###

/** * set中移除指定元素 * * @param key * @param value * @return */
    public Long removeSet(String key, Object value) { 
        Long size = null;
        try { 
            size = redisTemplate.opsForSet().remove(key, value);
        } catch (Exception e) { 
            log.error("[RedisUtils.removeSet] [error]", e);
            return size;
        }
        return size;
    }

###### 示例代码 ######

@Test
    public void removeSet() { 
        //key和value能查询到，返回1；存在对应的key，value不存在，返回0
        System.out.println(redisUtils.removeSet("word-book", "cat"));
        //key不存在，异常，返回null
        System.out.println(redisUtils.removeSet("111", "cat"));
    }

### 3. 计算集合大小 ###

/** * 计算set集合大小 * * @param key * @return */
    public Long countSet(String key) { 
        Long size = null;
        try { 
            size = redisTemplate.opsForSet().size(key);
        } catch (Exception e) { 
            log.error("[RedisUtils.countSet] [error]", e);
        }
        return size;
    }

###### 示例代码 ######

@Test
    public void countSet() { 
        //key存在，返回个数
        System.out.println(redisUtils.countSet("word-book"));
        //key不存在，异常
        System.out.println(redisUtils.countSet("111"));
    }

### 4. 判断集合中是否存在某元素 ###

/** * 判断set中是否存在某元素 * * @param key * @param value * @return */
    public Boolean hasMemberSet(String key, Object value) { 
        Boolean exist = false;
        try { 
            exist = redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) { 
            log.error("[RedisUtils.hasNumberSet] [error]", e);
        }
        return exist;
    }

###### 示例代码 ######

@Test
    public void hasMemberSet() { 
        //key和value存在，返回true
        System.out.println(redisUtils.hasMemberSet("word-book", "boy"));
        //key存在，value不存在，返回false
        System.out.println(redisUtils.hasMemberSet("word-book", "111"));
        //key不存在，异常
        System.out.println(redisUtils.hasMemberSet("111", "111"));
    }

### 5. 随机获取集合中的一个元素 ###

/** * 随机获取set中的一个元素 * * @param key * @return */
    public Object randomMember(String key) { 
        Object o = null;
        try { 
            o = redisTemplate.opsForSet().randomMember(key);
        } catch (Exception e) { 
            log.error("[RedisUtils.randomMember] [error]", e);
        }
        return o;
    }

###### 示例代码 ######

@Test
    public void randomMember() { 
        //key存在，返回元素
        System.out.println(redisUtils.randomMember("word-book"));
        //key不存在，异常
        System.out.println(redisUtils.randomMember("111"));
    }

### 6. 随机获取集合中的元素（指定个数，可能重复） ###

/** * 随机获取指定个数的元素（可能重复） * * @param key * @param num * @return */
    public List<Object> randomMembers(String key, Integer num) { 
        List<Object> o = null;
        try { 
            o = redisTemplate.opsForSet().randomMembers(key, num);
        } catch (Exception e) { 
            log.error("[RedisUtils.randomMember] [error]", e);
        }
        return o;
    }

###### 示例代码 ######

@Test
    public void randomNumMember() { 
        //key存在，随机返回5个，可能重复
        System.out.println(redisUtils.randomMembers("word-book", 5));
    }

### 7. 随机获取集合中的元素（指定个数，不重复） ###

/** * 随机获取集合内指定个数的元素（不重复） * * @param key * @param num * @return */
    public Set<Object> distinctRandomMembers(String key, Integer num) { 
        Set<Object> o = null;
        try { 
            o = redisTemplate.opsForSet().distinctRandomMembers(key, num);
        } catch (Exception e) { 
            log.error("[RedisUtils.randomMember] [error]", e);
        }
        return o;
    }

###### 示例代码 ######

@Test
    public void distinctRandomNumMember() { 
        //key存在，返回不重复的5个元素
        System.out.println(redisUtils.distinctRandomMembers("word-book", 5));
    }

### 8. 随机移除一个元素 ###

/** * 随机移除一个元素 * * @param key * @return */
    public Object popMember(String key) { 
        Object o = null;
        try { 
            o = redisTemplate.opsForSet().pop(key);
        } catch (Exception e) { 
            log.error("[RedisUtils.popMember] [error]", e);
        }
        return o;
    }

###### 示例代码 ######

@Test
    public void popMember() { 
        //key存在，返回删除的元素
        System.out.println(redisUtils.popMember("word-book"));
    }

### 9. 获取集合内的所有元素 ###

/** * 获取key下的所有元素 * * @param key * @return */
    public Set<Object> members(String key) { 
        Set<Object> result = null;
        try { 
            result = redisTemplate.opsForSet().members(key);
        } catch (Exception e) { 
            log.error("[RedisUtils.members] [error]", e);
        }
        return result;
    }

###### 示例代码 ######

@Test
    public void members() { 
        System.out.println(redisUtils.members("chinese-word"));
    }

### 10. 移动元素 ###

/** * 将key1集合中的元素value移到key2集合中 * * @param key1 * @param value * @param key2 * @return */
    public Boolean moveMember(String key1, Object value, String key2) { 
        Boolean result = false;
        try { 
            result = redisTemplate.opsForSet().move(key1, value, key2);
        } catch (Exception e) { 
            log.error("[RedisUtils.moveMember] [error]", e);
        }
        return result;
    }

###### 示例代码 ######

@Test
    public void moveMember() { 
        System.out.println(redisUtils.moveMember("word-book", "article", "chinese-word"));
        System.out.println(redisUtils.members("word-book"));
        System.out.println(redisUtils.members("chinese-word"));
    }

### 11. 两个集合取交集（两个key之间） ###

/** * 两个key之间取交集 * * @param key * @param key2 * @return */
    public Set<Object> intersectMember(String key, String key2) { 
        Set<Object> result = null;
        try { 
            result = redisTemplate.opsForSet().intersect(key, key2);
        } catch (Exception e) { 
            log.error("[RedisUtils.intersectMember] [error]", e);
        }
        return result;
    }

###### 示例代码 ######

@Test
    public void intersectMember() { 
        System.out.println(redisUtils.addSet("set-one", "one", "two", "three", "four", "five"));
        System.out.println(redisUtils.addSet("set-two", "one", "three", "ten", "nine"));
        System.out.println(redisUtils.intersectMember("set-one", "set-two"));
    }

### 12. 集合取交集（一个key与多个key之间） ###

/** * 一个集合与多个集合之间取交集 * * @param key * @param key2 * @return */
    public Set<Object> multiIntersectMember(String key, Set<String> key2) { 
        Set<Object> result = null;
        try { 
            result = redisTemplate.opsForSet().intersect(key, key2);
        } catch (Exception e) { 
            log.error("[RedisUtils.multiIntersectMember] [error]", e);
        }
        return result;
    }

###### 示例代码 ######

@Test
    public void multiIntersectMember() { 
        System.out.println(redisUtils.addSet("set-three", "three", "eight", "seven"));
        Set<String> set = new HashSet<>();
        set.add("set-three");
        set.add("set-two");
        System.out.println(redisUtils.multiIntersectMember("set-one", set));
    }

### 13. 集合取交集，并放入指定集合 ###

/** * 取交集并放入key3集合 * * @param key1 * @param key2 * @param key3 */
    public Long storeIntersectMember(String key1, String key2, String key3) { 
        Long result = null;
        try { 
            result = redisTemplate.opsForSet().intersectAndStore(key1, key2, key3);
        } catch (Exception e) { 
            log.error("[RedisUtils.storeIntersectMember] [error]", e);
        }
        return result;
    }

###### 示例代码 ######

@Test
    public void storeIntersectMember() { 
        System.out.println(redisUtils.intersectMember("set-one", "set-two"));
        System.out.println(redisUtils.members("set-four"));
        System.out.println(redisUtils.storeIntersectMember("set-one", "set-two", "set-four"));
        System.out.println(redisUtils.members("set-four"));
    }

### 14. 集合取并集（两个集合之间） ###

/** * 求并集 * * @param key1 * @param key2 * @return */
    public Set<Object> unionMember(String key1, String key2) { 
        Set<Object> objects = null;
        try { 
            objects = redisTemplate.opsForSet().union(key1, key2);
        } catch (Exception e) { 
            log.error("[RedisUtils.unionMember] [error]", e);
        }
        return objects;
    }

###### 示例代码 ######

@Test
    public void unionMember() { 
        System.out.println(redisUtils.unionMember("set-one", "set-two"));
    }

### 15. 集合取并集（一个集合与多个集合之间） ###

/** * 求并集（一个集合与多个集合之间） * * @param key1 * @param keys * @return */
    public Set<Object> multiUnionMember(String key1, Set<String> keys) { 
        Set<Object> objects = null;
        try { 
            objects = redisTemplate.opsForSet().union(key1, keys);
        } catch (Exception e) { 
            log.error("[RedisUtils.multiUnionMember] [error]", e);
        }
        return objects;
    }

###### 示例代码 ######

@Test
    public void multiUnionMember() { 
        Set<String> set = new HashSet<>();
        set.add("set-three");
        set.add("set-two");
        System.out.println(redisUtils.multiUnionMember("set-one", set));
    }