Redis 列表（List）方法使用详解

已于 2023-02-15 17:48:16 修改
阅读量7.8k 收藏 13
点赞数 2
分类专栏： Redis笔记 文章标签： redis opsForList
于 2022-12-15 16:03:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alian_1223/article/details/128268931
版权

目录

一、简介

  本文今天主要是介绍Redis 列表（List）的方法的使用，以及redis对应的Java实现该怎么用。因为篇幅问题，我这里写了一个测试类，引入 RedisTemplate对象，后面例子里就不一一引入了。大家理解就行，如果大家还不知道如何通过Spring Boot 整合redis则可以查看我之前的文章：SpringBoot整合redis（redis支持单节点和集群）

package com.alian.datastruct;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class RedisListTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
}

二、常用方法

2.1、LPUSH、RPUSH

  • LPUSH 将一个或多个值插入到列表头部
  • RPUSH 将一个或多个值插入到列表尾部

语法

LPUSH KEY_NAME VALUE1 VALUE2.. VALUEn
RPUSH KEY_NAME VALUE1 VALUE2.. VALUEn

命令操作

127.0.0.1:6379> lpush list1 python
(integer) 1
127.0.0.1:6379> lpush list1 Java
(integer) 2
127.0.0.1:6379> rpush list1 kotlin
(integer) 3
127.0.0.1:6379> lrange list1 0 -1
1) "Java"
2) "python"
3) "kotlin"

  需要注意的是，使用LPUSH和RPUSH，如果key不存在，就会自动创建这个key，这里的key就是list1。

Java操作

    @Test
    public void leftPushAndRightPush() {
        String redisKey="list1";
        redisTemplate.delete(redisKey);
        // 从列表的左边插入
        redisTemplate.opsForList().leftPush(redisKey,"Python");
        redisTemplate.opsForList().leftPush(redisKey,"Java");
        // 从列表的右边插入
        redisTemplate.opsForList().rightPush(redisKey,"Kotlin");
        // 输出全部列表
        List<Object> list = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("列表的信息：{}", list);
    }

列表的信息：[Java, python, kotlin]

2.2、LPUSHX、RPUSHX

  • LPUSHX 将一个值插入到已存在的列表头部
  • RPUSHX 将一个值插入到已存在的列表尾部

语法

LPUSHX KEY_NAME VALUE1 VALUE2.. VALUEn
RPUSHX KEY_NAME VALUE1 VALUE2.. VALUEn

命令操作

127.0.0.1:6379> lpushx list2 java
(integer) 0
127.0.0.1:6379> rpushx list2 javascript
(integer) 0
127.0.0.1:6379> lpush list2 kotlin
(integer) 1
127.0.0.1:6379> lpushx list2 go
(integer) 2
127.0.0.1:6379> rpushx list2 ios
(integer) 3
127.0.0.1:6379> lrange list2 0 -1
1) "go"
2) "kotlin"
3) "ios"
  • 使用LPUSHX和RPUSHX添加时，由于key（list2）不存在，则插入数据失败
  • 使用LPUSH加入kotlin后，就自动创建了key（list2）
  • 再使用LPUSHX和RPUSHX添加时，由于key（list2）存在，在列表的左侧插入go，右侧插入ios

Java操作

    @Test
    public void leftPushXAndRightPushX() {
        redisTemplate.delete(REDIS_KEY);
        String redisKey="list2";
        // 从列表的左边插入（如果key:list2存在）
        redisTemplate.opsForList().leftPushIfPresent(redisKey,"Java");
        // 从列表的右边插入（如果key:list2存在）
        redisTemplate.opsForList().rightPushIfPresent(redisKey,"Javascript");

        // 从列表的左边插入
        redisTemplate.opsForList().leftPush(redisKey,"kotlin");
        // 从列表的左边插入（如果key:list2存在）
        redisTemplate.opsForList().leftPushIfPresent(redisKey,"go");
        // 从列表的右边插入（如果key:list2存在）
        redisTemplate.opsForList().rightPushIfPresent(redisKey,"ios");
        // 输出全部列表
        List<Object> list = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("列表的信息：{}", list);
    }

列表的信息：[go, kotlin, ios]

2.3、LPOP、RPOP

  • LPOP 移除列表的第一个元素，返回值为移除的元素
  • RPOP 移除列表的最后一个元素，返回值为移除的元素

语法

LPOP KEY_NAME
RPOP KEY_NAME

命令操作

127.0.0.1:6379> lpush list3 Python Java Kotlin Go
(integer) 4
127.0.0.1:6379> lpop list3
"Go"
127.0.0.1:6379> rpop list3
"Python"
127.0.0.1:6379> lrange list3 0 -1
1) "Kotlin"
2) "Java"
  • 先初始化一个列表（list3）得到：Go、Kotlin、Java、Python
  • 从列表（list3）的左边弹出 Go
  • 从列表（list3）的右边边弹出 Python
  • 剩下的列表（list3）的元素：Kotlin、Java

Java操作

    @Test
    public void leftPopAndRightPop() {
        String redisKey="list3";
        redisTemplate.delete(redisKey);
        // 给列表list3插入多个数据
        redisTemplate.opsForList().leftPushAll(redisKey,"Python","Java","Kotlin","Go");
        // 从列表的左边弹出数据
        Object leftValue = redisTemplate.opsForList().leftPop(redisKey);
        log.info("左边弹出的数据：{}", leftValue);
        // 从列表的右边边弹出数据
        Object rightValue = redisTemplate.opsForList().rightPop(redisKey);
        log.info("右边边弹出的数据：{}", rightValue);
        // 输出全部列表
        List<Object> list = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("列表的信息：{}", list);
    }

左边弹出的数据：Go
右边边弹出的数据：Python
列表的信息：[Kotlin, Java]

2.4、RPOPLPUSH

  • RPOPLPUSH 移除列表的最后一个元素，并将该元素添加到另一个列表的头部并返回

语法

RPOPLPUSH SOURCE_KEY_NAME DESTINATION_KEY_NAME

命令操作

127.0.0.1:6379> rpush list4 Python Java Kotlin Go
(integer) 4
127.0.0.1:6379> rpoplpush list4 anotherList
"Go"
127.0.0.1:6379> lrange list4 0 -1
1) "Python"
2) "Java"
3) "Kotlin"
  • 先初始化一个列表（list4）得到：Python、Java、Kotlin、Go
  • 从列表（list4）的左边弹出 Go插入到新的列表（anotherList）
  • 剩下的列表（list4）的元素：Python、Java、Kotlin

Java操作

    @Test
    public void rightPopLeftPush() {
        String redisKey = "list4";
        redisTemplate.delete(redisKey);
        redisTemplate.delete("anotherList");
        // 给列表list4插入数据
        redisTemplate.opsForList().rightPushAll(redisKey,"Python","Java","Kotlin","Go");

        // 从列表的右边弹出一个原素，插入到另外一个列表，
        redisTemplate.opsForList().rightPopAndLeftPush(redisKey, "anotherList");
        // 输出列表信息
        List<Object> list = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("原列表的信息：{}", list);
        // 输出新列表信息
        List<Object> anotherList = redisTemplate.opsForList().range("anotherList", 0, -1);
        log.info("新列表的信息：{}", anotherList);
    }

原列表的信息：[Python, Java, Kotlin]
新列表的信息：[Go]

2.5、LEN

  • LEN 获取列表长度

语法

LLEN KEY_NAME

命令操作

127.0.0.1:6379> rpush list5 Python Java Kotlin Go
(integer) 4
127.0.0.1:6379> llen list5
(integer) 4
127.0.0.1:6379> llen list0
(integer) 0
  • 初始化列表（list5）得到：Python、Java、Kotlin、Go
  • 通过 llen 获取列表的长度，得到 4
  • 当列表（list0）不存在，长度为0

Java操作

    @Test
    public void length() {
        String redisKey = "list5";
        redisTemplate.delete(redisKey);
        // 给列表list5插入数据
        redisTemplate.opsForList().rightPushAll(redisKey,"Python","Java","Kotlin","Go");
        // 获取列表的长度
        Long size = redisTemplate.opsForList().size(redisKey);
        log.info("列表的长度：{}", size);
    }

列表的长度：4

2.6、LINDEX

  • LINDEX 通过索引获取列表中的元素

语法

LINDEX KEY_NAME INDEX_POSITION

命令操作

  列表从左往右是从 0 开始，列表从右往左是从 -1 开始

127.0.0.1:6379> rpush list6 Python Java Kotlin Go
(integer) 4
127.0.0.1:6379> lindex list6 0
"Python"
127.0.0.1:6379> lindex list6 1
"Java"
127.0.0.1:6379> lindex list6 2
"Kotlin"
127.0.0.1:6379> lindex list6 -1
"Go"
127.0.0.1:6379> lindex list6 -2
"Kotlin"
127.0.0.1:6379> lindex list6 -3
"Java"
  • 先初始化一个列表（list6）得到：Python、Java、Kotlin、Go
  • 获取列表（list6）中索引为 0 的数据，得到 Python
  • 获取列表（list6）中索引为 1 的数据，得到 Java
  • 获取列表（list6）中索引为 2 的数据，得到 Kotlin
  • 获取列表（list6）中索引为 -1 的数据，得到 Go
  • 获取列表（list6）中索引为 -2 的数据，得到 Kotlin
  • 获取列表（list6）中索引为 -3 的数据，得到 Java

Java操作

    @Test
    public void index() {
        String redisKey = "list6";
        redisTemplate.delete(redisKey);
        // 给列表list6插入数据
        redisTemplate.opsForList().rightPushAll(redisKey,"Python","Java","Kotlin","Go");

        // 获取列表中索引为【0】的数据
        Object value0 = redisTemplate.opsForList().index(redisKey, 0);
        log.info("列表中索引为【0】对应的值：{}", value0);
        // 获取列表中索引为【1】的数据
        Object value1 = redisTemplate.opsForList().index(redisKey, 1);
        log.info("列表中索引为【1】对应的值：{}", value1);
        // 获取列表中索引为【2】的数据
        Object value2 = redisTemplate.opsForList().index(redisKey, 2);
        log.info("列表中索引为【2】对应的值：{}", value2);

        // 获取列表中索引为【-1】的数据
        Object value3 = redisTemplate.opsForList().index(redisKey, -1);
        log.info("列表中索引为【-1】对应的值：{}", value3);
        // 获取列表中索引为【-2】的数据
        Object value4 = redisTemplate.opsForList().index(redisKey, -2);
        log.info("列表中索引为【-2】对应的值：{}", value4);
        // 获取列表中索引为【-3】的数据
        Object value5 = redisTemplate.opsForList().index(redisKey, -3);
        log.info("列表中索引为【-3】对应的值：{}", value5);
    }

列表中索引为【0】对应的值：Python
列表中索引为【1】对应的值：Java
列表中索引为【2】对应的值：Kotlin
列表中索引为【-1】对应的值：Go
列表中索引为【-2】对应的值：Kotlin
列表中索引为【-3】对应的值：Java

2.7、LRANGE

  • LRANGE 获取列表指定范围内的元素

语法

LRANGE KEY_NAME START END

命令操作

  返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。 其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。如果是负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推

127.0.0.1:6379> rpush list7 Python Java Kotlin Go Javascript
(integer) 5
127.0.0.1:6379> lrange list7 0 -1
1) "Python"
2) "Java"
3) "Kotlin"
4) "Go"
5) "Javascript"
127.0.0.1:6379> lrange list7 1 3
1) "Java"
2) "Kotlin"
3) "Go"
127.0.0.1:6379> lrange list7 -3 -1
1) "Kotlin"
2) "Go"
3) "Javascript"
  • 先初始化一个列表（list7 ）得到：Python、Java、Kotlin、Go、Javascript
  • 获取列表（list7）中索引从 0 到 -1 的列表，得到Python、Java、Kotlin、Go、Javascript
  • 获取列表（list7）中索引从 1 到 3 的列表，得到Java、Kotlin、Go
  • 获取列表（list7）中索引从 -3 到 -1 的列表，得到Kotlin、Go、Javascript

Java操作

    @Test
    public void range() {
        String redisKey = "list7";
        redisTemplate.delete(redisKey);
        // 给列表list7插入数据
        redisTemplate.opsForList().rightPushAll(redisKey,"Python","Java","Kotlin","Go","Javascript");

        // 获取指定范围的列表数据
        List<Object> result1 = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("列表中索引为【0】到【-1】的列表值：{}", result1);
        List<Object> result2 = redisTemplate.opsForList().range(redisKey, 1, 3);
        log.info("列表中索引为【1】到【3】的列表值：{}", result2);
        List<Object> result3 = redisTemplate.opsForList().range(redisKey, -3, -1);
        log.info("列表中索引为【-3】到【-1】的列表值：{}", result3);
    }

列表中索引为【0】到【-1】的列表值：[Python, Java, Kotlin, Go, Javascript]
列表中索引为【1】到【3】的列表值：[Java, Kotlin, Go]
列表中索引为【-3】到【-1】的列表值：[Kotlin, Go, Javascript]

2.8、LSET

  • LSET 通过索引设置列表元素的值

语法

LSET KEY_NAME INDEX VALUE

命令操作

127.0.0.1:6379> rpush list8 Python Java Kotlin Go Javascript
(integer) 5
127.0.0.1:6379> lset list8 3 IOS
OK
127.0.0.1:6379> lset list8 4 Android
OK
127.0.0.1:6379> lrange list8 0 -1
1) "Python"
2) "Java"
3) "Kotlin"
4) "IOS"
5) "Android"
  • 先初始化一个列表（list8 ）得到：Python、Java、Kotlin、Go、Javascript
  • 把列表（list8）中索引为 3 的数据改成，IOS
  • 把列表（list8）中索引为 4 的数据改成，Android
  • 获取列表（list8）中索引从 0 到 -1 的列表，得到Python、Java、Kotlin、IOS、Android

Java操作

    @Test
    public void set() {
        String redisKey = "list8";
        redisTemplate.delete(redisKey);
        // 给列表list8插入数据
        redisTemplate.opsForList().rightPushAll(redisKey,"Python","Java","Kotlin","Go","Javascript");

        // 把索引3和4分别设置为IOS、Android
        redisTemplate.opsForList().set(redisKey, 3, "IOS");
        redisTemplate.opsForList().set(redisKey, 4, "Android");
        // 获取列表中数据
        List<Object> result1 = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("列表中的数据为：{}", result1);
    }

列表中数据为：[Python, Java, Kotlin, IOS, Android]

2.9、LINSERT

  • LINSERT 在列表的元素前或者后插入元素

语法

LINSERT key BEFORE|AFTER pivot value

命令操作

127.0.0.1:6379> rpush list9 Python Java Kotlin
(integer) 3
127.0.0.1:6379> linsert list9 before Java IOS
(integer) 4
127.0.0.1:6379> linsert list9 after Java Android
(integer) 5
127.0.0.1:6379> lrange list9 0 -1
1) "Python"
2) "IOS"
3) "Java"
4) "Android"
5) "Kotlin"
  • 先初始化一个列表（list9 ）得到：Python、Java、Kotlin
  • 将IOS插入到列表（list9）中值为 Java 的前面
  • 将Android插入到列表（list9）中值为 Java 的后面
  • 获取列表（list9）中索引从 0 到 -1 的列表，得到Python、IOS、Java、Android、Kotlin

Java操作

    @Test
    public void insert() {
        String redisKey = "list9";
        redisTemplate.delete(redisKey);
        // 给列表list9插入数据
        redisTemplate.opsForList().rightPushAll(redisKey,"Python","Java","Kotlin");

        // 在Java前添加IOS
        redisTemplate.opsForList().leftPush(redisKey,"Java","IOS");
        // 在Java后添加Android
        redisTemplate.opsForList().rightPush(redisKey,"Java","Android");
        // 获取列表中数据
        List<Object> result1 = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("列表中数据为：{}", result1);
    }

列表中数据为：[Python, IOS, Java, Android, Kotlin]

2.10、LTRIM

  • LTRIM 对一个列表进行裁剪(trim)，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。

语法

LTRIM KEY_NAME START STOP

命令操作

127.0.0.1:6379> rpush list10 Python Java Kotlin Go Javascript IOS Android
(integer) 7
127.0.0.1:6379> ltrim list10 2 -1
OK
127.0.0.1:6379> lrange list10 0 -1
1) "Kotlin"
2) "Go"
3) "Javascript"
4) "IOS"
5) "Android"
127.0.0.1:6379> ltrim list10 0 -3
OK
127.0.0.1:6379> lrange list10 0 -1
1) "Kotlin"
2) "Go"
3) "Javascript"
127.0.0.1:6379> ltrim list10 1 2
OK
127.0.0.1:6379> lrange list10 0 -1
1) "Go"
2) "Javascript"
  • 先初始化一个列表（list10 ）得到：Python、Java、Kotlin、Go、Javascript、IOS、Android
  • 通过 ltrim 方法去除头部两个元素，得到Kotlin、Go、Javascript、IOS、Android
  • 通过 ltrim 方法去除尾部两个元素，得到Kotlin、Go、Javascript
  • 通过 ltrim 方法截取从1到2的元素，得到Go、Javascript

Java操作

    @Test
    public void trim() {
        String redisKey = "list10";
        redisTemplate.delete(redisKey);

        // 给列表list10插入数据
        redisTemplate.opsForList().rightPushAll(redisKey,"Python", "Java", "Kotlin", "Go", "Javascript","IOS","Android");
        List<Object> result = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("初始数据为：{}", result);

        // 去除头部两个元素
        redisTemplate.opsForList().trim(redisKey,2,-1);
        // 获取列表中数据
        List<Object> result1 = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("去除头部两个元素后列表中数据为：{}", result1);

        // 去除尾部两个元素
        redisTemplate.opsForList().trim(redisKey,0,-3);
        // 获取列表中数据
        List<Object> result2 = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("去除尾部两个元素后列表中数据为：{}", result2);

        // 截取列表中索引从1到2的数据
        redisTemplate.opsForList().trim(redisKey, 1, 2);
        // 获取列表中数据
        List<Object> result3 = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("截取列表中索引从1到2的数据后：{}", result3);
    }

初始数据为：[Python, Java, Kotlin, Go, Javascript, IOS, Android]
去除头部两个元素后列表中数据为：[Kotlin, Go, Javascript, IOS, Android]
去除尾部两个元素后列表中数据为：[Kotlin, Go, Javascript]
截取列表中索引从1到2的数据后：[Go, Javascript]

2.11、LREM

  • LTRIM 移除列表元素

语法

LREM KEY_NAME count VALUE
  • count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT
  • count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值
  • count = 0 : 移除表中所有与 VALUE 相等的值

命令操作

127.0.0.1:6379> rpush list11 Java Java Kotlin Java Java IOS Java
(integer) 7
127.0.0.1:6379> lrem list11 2 Java
(integer) 2
127.0.0.1:6379> lrange list11 0 -1
1) "Kotlin"
2) "Java"
3) "Java"
4) "IOS"
5) "Java"
127.0.0.1:6379> lrem list11 -1 Java
(integer) 1
127.0.0.1:6379> lrange list11 0 -1
1) "Kotlin"
2) "Java"
3) "Java"
4) "IOS"
127.0.0.1:6379> lrem list11 0 Java
(integer) 2
127.0.0.1:6379> lrange list11 0 -1
1) "Kotlin"
2) "IOS"
  • 先初始化一个列表（list11 ）得到：Java、Java、Kotlin、Java、Java、IOS、Java
  • 通过 lrem 方法去除头部2个Java ，得到Kotlin、Java、Java、IOS、Java
  • 通过 lrem 方法去除尾部1个Java ，得到Kotlin、Java、Java、IOS
  • 通过 lrem 方法去除所有Java ，得到Kotlin、IOS
    Java操作
    @Test
    public void count() {
        String redisKey = "list11";
        redisTemplate.delete(redisKey);

        // 给列表list11插入数据
        redisTemplate.opsForList().rightPushAll(redisKey, "Java", "Java", "Kotlin", "Java", "Java", "IOS", "Java");

        // 从头部开始移除2个Java
        redisTemplate.opsForList().remove(redisKey,2,"Java");
        // 获取列表中数据
        List<Object> result1 = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("从头部开始移除2个Java值后：{}", result1);

        // 从尾部部开始移除1个Java
        redisTemplate.opsForList().remove(redisKey,-1,"Java");
        // 获取列表中数据
        List<Object> result2 = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("从尾部部开始移除1个Java值后：{}", result2);

        // 移除列表中的所有的Java
        redisTemplate.opsForList().remove(redisKey,0,"Java");
        // 获取列表中数据
        List<Object> result3 = redisTemplate.opsForList().range(redisKey, 0, -1);
        log.info("移除列表中的所有的Java值后：{}", result3);
    }

从头部开始移除2个Java值后：[Kotlin, Java, Java, IOS, Java]
从尾部部开始移除1个Java值后：[Kotlin, Java, Java, IOS]
移除列表中的所有的Java值后：[Kotlin, IOS]

2.12、BLPOP、BRPOP

  • BLPOP 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
  • BRPOP 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止

语法

BLPOP LIST1 LIST2 ... LISTn TIMEOUT
BRPOP LIST1 LIST2 ... LISTn TIMEOUT

命令操作

127.0.0.1:6379> rpush list12 Java Python
(integer) 2
127.0.0.1:6379> blpop list12 10
1) "list12"
2) "Java"
127.0.0.1:6379> brpop list12 10
1) "list12"
2) "Python"
127.0.0.1:6379> blpop list12 10
(nil)
(10.01s)
127.0.0.1:6379> brpop list12 10
(nil)
(10.01s)
  • 先初始化一个列表（list12 ）得到：Java、Python
  • 通过 blpop 方法弹出头部一个元素，得到Java
  • 通过 brpop 方法弹出尾部一个元素，得到Python，此时列表为空
  • 通过 blpop 方法弹出头部一个元素，结果10秒后超时（列表为空）
  • 通过 brpop 方法弹出尾部一个元素，结果10秒后超时（列表为空）

终端一

127.0.0.1:6379> blpop list12 10
(nil)
(10.05s)
127.0.0.1:6379> blpop list12 10

终端二

127.0.0.1:6379> lpush list12 Scala
(integer) 1

  此时终端一会马上得到结果，详细见下图

在这里插入图片描述

  • 在终端一 blpop 方法弹出空列表 list12 头部一个元素，如果没有数据则10秒后超时
  • 在终端二中我们给空列表 list12 ，插入一个数据 Scala
  • 终端一马上弹出了，终端二插入的数据 Scala ，阻塞终止

Java操作

    @Test
    public void bLeftPopAndBRightPop() {
        String redisKey = "list12";
        redisTemplate.delete(redisKey);
        // 给列表list12插入数据
        redisTemplate.opsForList().leftPushAll(redisKey, "Python", "Java");

        // 从列表头部弹出元素，超时时间为30秒
        Object value1 = redisTemplate.opsForList().leftPop(redisKey, 30, TimeUnit.SECONDS);
        log.info("从列表头部阻塞弹出元素：{}", value1);
        // 从列表尾部弹出元素，超时时间为30秒
        Object value2 = redisTemplate.opsForList().rightPop(redisKey,30, TimeUnit.SECONDS);
        log.info("从列表尾部阻塞弹出元素：{}", value2);

        try {
            // 此时是空列表了，继续头部弹出，此时会阻塞，如果30秒内列表还有元素，就会超时
            redisTemplate.opsForList().leftPop(redisKey,30, TimeUnit.SECONDS);
//            redisTemplate.opsForList().rightPop(redisKey,30, TimeUnit.SECONDS);
        } catch (Exception e) {
            log.info("阻塞弹出数据超时");
        }
    }

从列表头部阻塞弹出元素：Java
从列表尾部阻塞弹出元素：Python
阻塞弹出数据超时

2.13、BRPOPLPUSH

  • BRPOPLPUSH 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止

语法

BRPOPLPUSH LIST1 ANOTHER_LIST TIMEOUT

命令操作

127.0.0.1:6379> rpush list13 Java Python
(integer) 2
127.0.0.1:6379> brpoplpush list13 newlist 10
"Python"
127.0.0.1:6379> brpoplpush list13 newlist 10
"Java"
127.0.0.1:6379> brpoplpush list13 newlist 10
(nil)
(10.02s)
127.0.0.1:6379> lrange newlist 0 -1
1) "Java"
2) "Python"
  • 先初始化一个列表（list13 ）得到：Java、Python
  • 通过 brpoplpush 方法弹出尾部一个元素，得到Python，并插入到一个新的列表 newlist
  • 通过 brpoplpush 方法弹出尾部一个元素，得到Java，并插入到一个新的列表 newlist ，此时列表list13 为空
  • 通过 brpoplpush 方法弹出尾部一个元素，结果10秒后超时（列表为空）
  • 通过 lrange 方法查看新列表（ newlist ）的数据，得到Java、Python

同样的，为了验证阻塞，我们开启另外一个终端，往空列表 list13 写入数据

终端二

127.0.0.1:6379> lpush list13 Scala
(integer) 1

终端一

127.0.0.1:6379> brpoplpush list13 newlist 10
(nil)
(10.05s)
127.0.0.1:6379> brpoplpush list13 newlist 10
"Scala"
(3.57s)
127.0.0.1:6379> lrange newlist 0 -1
1) "Scala"
2) "Java"
3) "Python"
  • 在终端一 brpoplpush 方法弹出空列表 list13 尾部一个元素，如果没有数据则10秒后超时
  • 在终端二中我们给空列表 list13 ，插入一个数据 Scala
  • 终端一马上弹出了，终端二插入的数据 Scala ，阻塞终止
  • 通过 lrange 方法查看新列表（ newlist ）的数据，得到Scala、Java、Python

Java操作

    @Test
    public void bRightPopAndLeftPush() {
        String redisKey = "list13";
        redisTemplate.delete(redisKey);
        // 给列表list13插入数据
        redisTemplate.opsForList().leftPushAll(redisKey, "Python", "Java", "Kotlin", "Go");

        // 从列表尾部弹出元素，插入到另外一个列表的头部，超时时间为30秒
        redisTemplate.opsForList().rightPopAndLeftPush(redisKey,"newList",30, TimeUnit.SECONDS);
    }
嘉禾嘉宁papa
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis列表(list)使用
蜗牛学习笔记
02-08 1万+
Redis的列表是一种线性的有序结构，可以按照元素推入列表中的顺序来存储元素，并且列表中的元素可以重复出现；用户可以使用lpush、rpush、rpop、lpop等命令，从列表的两端推入或者弹出元素，也可以通过linsert命令将新元素插入列表已有元素的前面或者后面；用户可以使用lrem命令从列表中移除指定的元素，或者使用ltrim命令对列表进行修剪；使用lrange命令查看列表指定索引范围内元素信息，使用lrange查看列表所有元素；当用户传给lrange命令的索引范围超出了列表
redis数据类型之list(列表)
zjwendy的博客
05-05 703
文章目录一、队列二、栈三、其他操作四、内部实现压缩表（ziplist）快速列表 list是链表不是数组，故其插入和删除操作非常快，时间复杂度为O(1),但是索引定位很慢，时间复杂度为O(n)。 一、队列 > rpush numbers one two three (integer) 3 > llen numbers (integer) 3 > lpop numbers "one"...
Redis五大数据类型——List列表
祝我飞黄腾达
12-17 1万+
Redis五大数据类型：String（字符串），Hash（哈希），List（列表），Set（集合）及Zset(sorted set：有序集合)。 一、介绍 列表(list)用于存储多个有序的字符串。可以充当栈和队列的角色 一般有序会采用数组或者是双向链表，其中双向链表由于有前后指针实际上会很浪费内存。 二、操作命令 操作类型 命令 添加 rpush、lpush、linsert 修改 lset 删除 lpop、rp...
list
10-27 231
list类型 列表的元素类型为string 按照插入顺序排序 增加 在左侧插⼊数据 lpush key value1 value2 … 例1：从键为a1的列表左侧加⼊数据a 、 b 、c lpush a1 a b c 在右侧插⼊数据 rpush key calue1 value2 … 例2：从键为a1的列表右侧加⼊数据0、1 rpush a1 0 1 ...
Redis常用命令——List篇
最新发布
weixin_67596609的博客
06-01 1655
列表类型是用来存储多个有序的字符串，如下图所示，a、b、c、 d、e五个元素从左到右组成了一个有序的列表，列表中的每个字符串称为元素(element) ，一个列表最多可以存储2^32-1个元素。在Redis 中，可以对列表两端插入(push)和弹出 (pop)，还可以获取指定范围的元素列表、获取指定索引下标的元素等。列表是一种比较灵活的数据结构，它可以充当栈和队列的角色，在实际开发上有很多应用场景。
Redis中List的使用
weixin_45193103的博客
03-24 5530
List（列表)-介绍 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边)或者尾部（右边)。 List本质是个链表, List的元素是有序的，元素的值可以重复。 举例,存放多个地址信息:city 北京天津上海 说明: key : city 北京 天津 上海就是三个元素 list相当于一个队列的感觉，先进来的会放在后面，如下图所示 Lrange的基本语法： LRANGE key start stop List可以想象成一个管道，从两头都可以进行元素的添加。.
使用RedisTemplate缓存List的一系列操作示例
热门推荐
weixin_42216142的博客
07-15 3万+
redisTemplate是Spring封装的一个比较强大的模板，方便在开发的时候操作redis缓存。 Redis缓存一般能存的类型有String、List、Set、Hash、Zset。 一般最常用的是Hash和List。 List 判断一个键是否存在 Boolean flag = redisTemplate.hasKey("keyName") 获取缓存的指定区间数据 redisTemplate...
redis基本类型和使用方法详解
09-08
Redis 是一个高性能的键值数据库，它提供了丰富的数据类型，包括字符串(String)、散列(Hash)、列表(List)、集合(Set)和有序集合(ZSet)。这些数据类型支持多种操作，使得 Redis 能够满足各种场景的需求。下面将详细...
Redis List列表的详细介绍
09-09
Redis List是Redis数据结构中的一种，它是一个简单的字符串列表，按照插入顺序进行排序。这个数据结构非常适合用作消息队列，因为你可以轻松地在列表的两端（头或尾）添加和移除元素。以下是关于Redis List更详细的...
Redis介绍和使用场景详解
08-27
Redis介绍和使用场景详解 在这篇文章中，我们主要介绍了Redis的介绍和使用场景，并对其进行了详细的分析和比较。下面是相关的知识点： 1. 持久化数据库的缺点 关系型数据库，如Mysql、Oracle和SqlServer等，在开发...
Redis常用语法命令及使用示例详解
05-06
它支持多种数据类型，包括字符串（string）、哈希（hash）、列表（list）、集合（set）、有序集合（sorted set）等，并提供了丰富的命令集来操作这些数据类型。Redis支持发布/订阅（Pub/Sub）模型，允许客户端订阅...
Redis——list类型详解
m0_60867520的博客
08-17 1395
Redis中的list类型常用命令，编码方式和应用场景
Redis的List的应用场景
weixin_42119753的博客
10-09 5276
一、概述 Redis中列表（list）类型是用来存储多个有序的字符串，列表中的每个字符串成为元素（element），一个列表最多可以存储2^32 - 1个元素。 在Redis中，可以对列表两端插入（push）和弹出（pop），还可以获取指定范围的元素列表、获取指定索引下标的元素等。列表是一种比较灵活的数据结构，可以充当栈和队列的角色，在实际开发中有很多应用场景。 列表类型有以下特点： ...
Redis命令---List篇
gzu_01的博客
01-04 1672
Redis Lindex 命令用于通过索引获取列表中的元素。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。Redis 列表(List)注意：在 Redis 2.4 版本以前的 RPUSH 命令，都只接受单个 value 值。如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。当列表存在但不是列表类型时，返回一个错误。Redis Rpush 命令用于将一个或多个值插入到列表的尾部(最右边)。Redis 列表(List)
redis的list类型
ajqy4635的博客
08-27 635
1、简单介绍 　　redis的list类型其实就是一个每个元素都是string类型的双向链表。所以lpush、rpush、lpop和rpop命令的时间复杂度是O(1)，list会记录链表的长度，所以llen操作也是O（1）的时间复杂度。链表的最大长度是2的32次方减1,。list类型可以用作队列或者栈。list还有阻塞版本，就是说如果队列为空，就会等待直到超时或者有数据放入队列。阻塞...
redis学习-14- Redis list列表操作
时光
04-24 1113
redis学习-14- Redis list列表操作
【Redis】Redis 列表 List 操作 ( 查询操作 | 根据下标获取元素 | 获取列表长度 | 增操作 | 插入值 | 删操作 | 移除值 | 修改操作 | 设置列表指定索引的值 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
02-17 1万+
一、List 列表简介 二、查询操作 1、根据下标获取元素 2、获取指定下标索引的元素 3、获取列表长度 三、增操作 1、插入值 2、在指定元素前后插入值 四、删操作 1、移除值 2、删除列表指定个数的指定值 五、修改操作 1、多列表操作 2、设置列表指定索引的值
Redis 基础 -- 列表 List 类型 和 List 类型的常用命令
天行健 君子以自强不息，地势坤 君子以厚德载物。
05-03 3048
Redis的列表（list）是一种线性的有序结构，可以按照元素被推入列表中的顺序来存储元素，这些元素既可以是文字数据，又可以是二进制数据，并且列表中的元素可以重复出现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值