leaflet hello world

Redis List

Redis 的 List 是一个链表结构，是一个每个子元素都是 string 类型的双向链表，链表的最大长度是(2
的 32 次方)。以下是 Redis 对 List 的操作命令：

RPUSH key element [element …]

将一个或多个元素一个一个的推入链表尾部，如果 key 不存在则初始化一个空的 list 再推入。成功返回链表长度。

    @Test
    public void rpush() {
        Assert.assertEquals(4, listCommands.rpush("key-rpush", "a", "b", "c", "d").longValue());
        List<String> res = listCommands.lrange("key-rpush", 0, -1);
        Assert.assertArrayEquals(new String[]{"a", "b", "c", "d"}, res.toArray(new String[]{}));
    }

RPUSHX key element [element …]

将一个或多个元素推入链表尾部，链表如果不存在则操作无效，成功返回链表长度， key 不存在时无操作所以返回长度为 0 。

    @Test
    public void rpushx() {
        Assert.assertEquals(0, listCommands.rpushx("key-rpushx", "a").longValue());
        listCommands.rpush("key-rpushx", "a");
        Assert.assertEquals(2, listCommands.rpushx("key-rpushx", "b").longValue());
        List<String> res = listCommands.lrange("key-rpushx", 0, -1);
        Assert.assertArrayEquals(new String[]{"a", "b"}, res.toArray(new String[]{}));
    }

LPUSH key element [element …]

将一个或多个元素一个一个的推入链表头部，如果 key 不存在则初始化一个空的 list 再推入。如 a b c 则会按照顺序一个个推入头部，最后链表为 c b a 。成功返回链表长度。

    @Test
    public void lpush() {
        Assert.assertEquals(4, listCommands.lpush("key-lpush", "a", "b", "c", "d").longValue());
        List<String> res = listCommands.lrange("key-lpush", 0, -1);
        Assert.assertArrayEquals(new String[]{"d", "c", "b", "a"}, res.toArray(new String[]{}));
    }

LPUSHX key element [element …]

将一个或多个元素一个一个的推入链表头部，链表如果不存在则操作无效。成功返回链表长度。

    @Test
    public void lpushx() {
        Assert.assertEquals(0, listCommands.lpushx("key-lpushx", "a").longValue());
        listCommands.lpush("key-lpushx", "a");
        Assert.assertEquals(2, listCommands.lpushx("key-lpushx", "b").longValue());
        List<String> res = listCommands.lrange("key-lpushx", 0, -1);
        Assert.assertArrayEquals(new String[]{"b", "a"}, res.toArray(new String[]{}));
    }

RPOP key

从链表尾部弹出一个元素，如果弹出元素后链表为空则删除 key ，成功返回弹出的元素。

    @Test
    public void rpop() {
        listCommands.rpush("key-rpop", "a", "b", "c", "d");
        Assert.assertEquals("d", listCommands.rpop("key-rpop"));
    }

LPOP key

从链表头部弹出一个元素，如果弹出元素后链表为空则删除 key ，成功返回弹出的元素。

    @Test
    public void lpop() {
        listCommands.rpush("key-lpop", "a", "b", "c", "d");
        Assert.assertEquals("a", listCommands.lpop("key-lpop"));
    }

LTRIM key start stop

修剪链表，只保留索引在（包括）start stop 之间的元素，如果 start 超出范围，则 key 就删除了。成功返回 OK 。

    @Test
    public void ltrim() {
        listCommands.rpush("key-ltrim", "a", "b", "c", "d");
        Assert.assertEquals("OK", listCommands.ltrim("key-ltrim", 1, 2));
        List<String> res = listCommands.lrange("key-ltrim", 0, -1);
        Assert.assertArrayEquals(new String[]{"b", "c"}, res.toArray(new String[]{}));
    }

LINSERT key BEFORE|AFTER pivot element

从头部开始寻找指定值为 pivot 的元素并在其前面后者后面插入新元素。成功返回链表长度，如果 pivot 不存在则返回 -1 。

    @Test
    public void linsert() {
        listCommands.rpush("key-linsert", "a", "b", "c", "d");
        Assert.assertEquals(5, listCommands.linsert("key-linsert", false, "c", "c1").longValue());
        List<String> res = listCommands.lrange("key-linsert", 0, -1);
        Assert.assertArrayEquals(new String[]{"a", "b", "c", "c1", "d"}, res.toArray(new String[]{}));
        Assert.assertEquals(-1, listCommands.linsert("key-linsert", false, "e", "e1").longValue());
    }

LSET key index element

将链表索引为 index 的元素设置为新的 element，如果 index 超出链表范围报错，成功返回 OK 。

    @Test
    public void lset() {
        listCommands.rpush("key-lset", "a", "b", "c", "d");
        Assert.assertEquals("OK", listCommands.lset("key-lset", 2, "c1"));
        List<String> res = listCommands.lrange("key-lset", 0, -1);
        Assert.assertArrayEquals(new String[]{"a", "b", "c1", "d"}, res.toArray(new String[]{}));
    }

LREM key count element

从头部（count>0）或从尾部（count<0）开始删除 count 个值等于 element 的元素，count=0 则删除全部，成功返回被删除的元素个数。

    @Test
    public void lrem() {
        listCommands.rpush("key-lrem", "a", "b", "c", "c1", "c", "c", "d");
        Assert.assertEquals(2, listCommands.lrem("key-lrem", 2, "c").longValue());
        List<String> res = listCommands.lrange("key-lrem", 0, -1);
        Assert.assertArrayEquals(new String[]{"a", "b", "c1", "c", "d"}, res.toArray(new String[]{}));
    }

LLEN key

获得链表的长度，成功返回链表长度，如果 key 不存在则返回 0 。

    @Test
    public void llen() {
        listCommands.rpush("key-llen", "a", "b", "c", "d");
        Assert.assertEquals(4, listCommands.llen("key-llen").longValue());
    }

LINDEX key index

返回链表中索引为 index 的元素，注意不是弹出，成功返回元素。

    @Test
    public void lindex() {
        listCommands.rpush("key-lindex", "a", "b", "c", "d");
        Assert.assertEquals("c", listCommands.lindex("key-lindex", 2));
    }

LRANGE key start stop

返回链表中索引在（包括）start stop 之间的元素，注意不是弹出，成功返回元素。start 和 stop 也可以接受负数，如 -1 代表最后一个元素。

    @Test
    public void lrange() {
        listCommands.rpush("key-lrange", "a", "b", "c", "d");
        List<String> res = listCommands.lrange("key-lrange", 0, 3);
        Assert.assertArrayEquals(new String[]{"a", "b", "c", "d"}, res.toArray(new String[]{}));
        res = listCommands.lrange("key-lrange", -2, -1);
        Assert.assertArrayEquals(new String[]{"c", "d"}, res.toArray(new String[]{}));
    }

源码地址

https://github.com/RockeyCui/learn-normal/tree/master/learn-redis/src/test/java/com/rock/learn/redis/lettuce

---

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 rockeycui@163.com