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

引用：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        }    }

RedisTemplate访问Redis数据结构（前言）
RedisTemplate访问Redis数据结构（一）——String
RedisTemplate访问Redis数据结构（二）——List
RedisTemplate访问Redis数据结构（三）——Hash
RedisTemplate访问Redis数据结构（四）——Set
RedisTemplate访问Redis数据结构（五）——ZSet