1. Jedis Set Demos

对应redis命令参考：redis set组命令

package samples.cache.jedis;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Set;

import redis.clients.jedis.Jedis;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

/**
 * @author Zi Lai Ye
 * @date 2017/10/16
 */
public class JedisSetTests {
    public static final Logger logger = LoggerFactory.getLogger(JedisListTests.class);

    public static final String HOST = "localhost";
    public static final int PORT = 6379;

    private Jedis jedis;

    public static final String skey1 = "skey1";
    public static final String skey2 = "skey2";

    public static final String key1 = "key1";


    public static final Long ONE = 1L;
    public static final Long ZERO = 0L;

    @Before
    public void beforeClass() {
        jedis = new Jedis(HOST, PORT);
//        jedis.flushDB();
    }

    @After
    public void afterClass() {
//        jedis.flushDB();
        jedis.close();
    }

    @Test
    public void sadd() {
        if (jedis.exists(skey1)) {
            jedis.del(skey1);
        }

        // key 不存在, 会自动创建的
        Long saddResult = jedis.sadd(skey1, "a");
        assertEquals(ONE, saddResult);

        // 如果添加的元素已存在, 不会重复再添加
        saddResult = jedis.sadd(skey1, "a");
        assertEquals(ZERO, saddResult);
        assertEquals(ONE, jedis.scard(skey1));

        // 如果类型不是set
        jedis.set(key1, "v1");

        try {
            saddResult = jedis.sadd(key1, "b");
        } catch (Exception e) {
            logger.error("key 类型不是set类型, 报错:", e);
        }
    }

    @Test
    public void scard() {
        delIfExists(skey1);

        // key 不存在, 返回 0
        Long scardResult = jedis.scard(skey1);
        assertEquals(ZERO, scardResult);

        initSset1();

        scardResult = jedis.scard(skey1);
        assertEquals(Long.valueOf(10), scardResult);

        // key 不是set类型, 报错
        jedis.set(key1, "v1");

        try {
            jedis.scard(key1);
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    // 求在集合A中并不在集合B、C中的差集
    @Test
    public void sdiff() {
        delIfExists(skey1);
        delIfExists(skey2);

        // key1 不存在, 则其与任何集合的差集都是空集
        Set<String> sdiff = jedis.sdiff(skey1);
        assertNotNull(sdiff);
        assertEquals(0, sdiff.size());

        // key2 初始化 4-7
        for (int i = 4; i < 7; i++) {
            jedis.sadd(skey2, String.valueOf(i));
        }

        // key2 存在, key1不存在, key1 diff key2 还是空
        sdiff = jedis.sdiff(skey1, skey2);
        assertEquals(0, sdiff.size());

        // key1 初始化 1-5
        for (int i = 1; i <= 5; i++) {
            jedis.sadd(skey1, String.valueOf(i));
        }

        // 只传 key1, 不传被比较的 set, 返回 set1自身
        sdiff = jedis.sdiff(skey1);
        assertEquals(5, sdiff.size());

        // 返回在 set1 中存在, set2中不存在的元素组成的集合
        sdiff = jedis.sdiff(skey1, skey2);
        assertEquals(3, sdiff.size());
        assertTrue(sdiff.contains(String.valueOf(1)));
        assertTrue(sdiff.contains(String.valueOf(2)));
        assertTrue(sdiff.contains(String.valueOf(3)));

        // 如果参数中的任意一个 key 不是 set 类型, 报错
        jedis.set(key1, "v1");

        try {
            jedis.sdiff(key1, skey2);
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
        try {
            jedis.sdiff(skey1, key1);
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    // 求集合的交集
    @Test
    public void sinter() {
        delIfExists(skey1);
        delIfExists(skey2);

        // 任意一个 key 为空集, 交集即为空集
        Set<String> sinter = jedis.sinter(skey1);
        assertEquals(0, sinter.size());

        // key2 初始化 4-7
        for (int i = 4; i < 7; i++) {
            jedis.sadd(skey2, String.valueOf(i));
        }

        sinter = jedis.sinter(skey1, skey2);
        assertEquals(0, sinter.size());

        sinter = jedis.sinter(skey2, skey1);
        assertEquals(0, sinter.size());

        // key1 初始化 1-5
        for (int i = 1; i <= 5; i++) {
            jedis.sadd(skey1, String.valueOf(i));
        }

        // 取 set1 和 set2 的交集, 即4、5两个元素
        sinter = jedis.sinter(skey1, skey2);
        assertEquals(2, sinter.size());
        assertTrue(sinter.contains(String.valueOf(4)));
        assertTrue(sinter.contains(String.valueOf(5)));

        // 参数任意一个key不是set类型,报错
        jedis.set(key1, "");

        try {
            jedis.sinter(key1, skey1);
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
        try {
            jedis.sinter(skey1, key1);
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    // 求集合的并集
    @Test
    public void sunion() {
        delIfExists(skey1);
        delIfExists(skey2);

        // 不存在的 key 被认定为空集合, 两个空集合的并集 还是空
        Set<String> sunion = jedis.sunion(skey1);
        assertEquals(0, sunion.size());

        sunion = jedis.sunion(skey1, skey2);
        assertEquals(0, sunion.size());

        // key2 初始化 4-7
        for (int i = 4; i < 7; i++) {
            jedis.sadd(skey2, String.valueOf(i));
        }

        sunion = jedis.sunion(skey1, skey2);
        assertEquals(4, sunion.size());

        // key1 初始化 1-5
        for (int i = 1; i <= 5; i++) {
            jedis.sadd(skey1, String.valueOf(i));
        }

        // 并集为 1-7
        sunion = jedis.sunion(skey1, skey2);
        assertEquals(7, sunion.size());

        // key 为 非set类型, 报错
        jedis.set(key1, "v1");

        try {
            jedis.sunion(key1, skey1);
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    @Test
    public void sismember() {
        delIfExists(skey1);

        // key 不存在, 认为是空集合, 元素不在集合内, 返回false
        assertFalse(jedis.sismember(skey1, "1"));

        // 使用1-10元素初始化集合
        initSset1();

        // 判断元素是否在集合内
        for (int i = 1; i <= 10; i++) {
            assertTrue(jedis.sismember(skey1, String.valueOf(i)));
        }
        assertFalse(jedis.sismember(skey1, "a"));

        // key 不是set类型
        jedis.set(key1, "v1");
        try {
            jedis.sismember(key1, "a");
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    @Test
    public void smembers() {
        delIfExists(skey1);

        // key 不存在, 返回空
        Set<String> smembers = jedis.smembers(skey1);
        assertNotNull(smembers);
        assertEquals(0, smembers.size());

        // 1-10初始化skey1
        initSset1();

        smembers = jedis.smembers(skey1);
        assertEquals(jedis.scard(skey1), Long.valueOf(smembers.size()));
        for (int i = 1; i <= 10; i++) {
            assertTrue(smembers.contains(String.valueOf(i)));
        }

        // key 不是 set 类型, 返回错误
        jedis.set(key1, "v1");
        try {
            jedis.smembers(key1);
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    @Test
    public void smove() {
        delIfExists(skey1);
        delIfExists(skey2);

        // skey1 skey2 都不存在, 不做任何操作
        Long smove = jedis.smove(skey1, skey2, "1");
        assertEquals(ZERO, smove);

        // key1 初始化 1-5
        for (int i = 1; i <= 5; i++) {
            jedis.sadd(skey1, String.valueOf(i));
        }

        // destination 不存在, 创建之
        smove = jedis.smove(skey1, skey2, "1");
        assertEquals(ONE, smove);
        assertEquals(ONE, jedis.scard(skey2));
        assertEquals(Long.valueOf(4), jedis.scard(skey1)); // set1 减 1个
        assertFalse(jedis.smembers(skey1).contains("1"));

        // destination 中已存在 member, 从source中移除, destination 不添加
        jedis.sadd(skey1, "1");
        assertTrue(jedis.smembers(skey1).contains("1"));
        assertTrue(jedis.smembers(skey2).contains("1"));

        smove = jedis.smove(skey1, skey2, "1");
        assertEquals(ONE, smove);
        assertFalse(jedis.smembers(skey1).contains("1"));

        // key 不是 set 报错
        jedis.set(key1, "v1");

        try {
            jedis.smove(key1, skey2, "1");
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
        try {
            jedis.smove(skey1, key1, "1");
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    @Test
    public void spop() {
        delIfExists(skey1);

        // key 不存在, 返回 null 或 空集合
        assertNull(jedis.spop(skey1));
        Set<String> spop = jedis.spop(skey1, 1);
        assertNotNull(spop);
        assertEquals(0, spop.size());

        // 1-10初始化
        initSset1();

        // 不带count参数
        String spopResult = jedis.spop(skey1);
        assertNotNull(spopResult);
        assertEquals(Long.valueOf(9), jedis.scard(skey1));

        // 带count参数
        spop = jedis.spop(skey1, 3);
        assertNotNull(spop);
        assertEquals(3, spop.size());
        assertEquals(Long.valueOf(6), jedis.scard(skey1));

        // key 不是集合
        jedis.set(key1, "v1");
        try {
            jedis.spop(key1);
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    @Test
    public void srandmember() {
        delIfExists(skey1);

        // key 不存在, 返回 null 或 空集合
        assertNull(jedis.srandmember(skey1));
        assertEquals(0, jedis.srandmember(skey1, 1).size());

        // 用 1 - 10 初始化 set
        initSset1();

        // 随机获取1个元素, 不传count
        String srandmember = jedis.srandmember(skey1);
        assertNotNull(srandmember);
        assertEquals(Long.valueOf(10), jedis.scard(skey1)); // 集合数量不变

        // 随机获取多个元素, 传count
        List<String> srandmembers = jedis.srandmember(skey1, 4);
        assertEquals(4, srandmembers.size());

        // 如果 count > set size, 返回整个集合
        srandmembers = jedis.srandmember(skey1, 20);
        assertEquals(10, srandmembers.size());

        // 如果 count < 0, 返回绝对值个元素
        srandmembers = jedis.srandmember(skey1, -2);
        assertEquals(2, srandmembers.size());

        // 如果 count < 0, 且绝对值 > set size, 返回 count 绝对值个元素, 元素会出现重复
        srandmembers = jedis.srandmember(skey1, -20);
        assertEquals(20, srandmembers.size());

        // if key 不是 set 类型, 报错
        jedis.set(key1, "v1");

        try {
            jedis.srandmember(key1);
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    @Test
    public void srem() {
        delIfExists(skey1);

        // key 不存在, 什么也不做, 影响行数为 0
        Long srem = jedis.srem(skey1, "1");
        assertEquals(ZERO, srem);

        // 1 - 10 初始化一个set
        initSset1();

        // 删除集合中指定元素
        srem = jedis.srem(skey1, "1", "2");
        assertEquals(Long.valueOf(2), srem);
        assertEquals(Long.valueOf(8), jedis.scard(skey1));//还剩下8个元素

        // member 不存在, 什么也不做, 返回 0
        srem = jedis.srem(skey1, "1");
        assertEquals(ZERO, srem);

        // member 重复, 忽略
        srem = jedis.srem(skey1, "3", "3");
        assertEquals(ONE, srem);
        assertEquals(Long.valueOf(7), jedis.scard(skey1));

        // key 不是 set 类型, 报错
        jedis.set(key1, "v1");
        try {
            jedis.srem(key1, "1");
        } catch (Exception e) {
            logger.error("key 不是 set 类型, 报错: ", e);
        }
    }

    private void initSset1() {
        delIfExists(skey1);

        for (int i = 1; i <= 10; i++) {
            jedis.sadd(skey1, String.valueOf(i));
        }
    }

    private void delIfExists(String key) {
        if (jedis.exists(key)) {
            jedis.del(key);
        }
    }
}