Redis的数据结构之 list

最新推荐文章于 2024-05-28 22:52:09 发布
最新推荐文章于 2024-05-28 22:52:09 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： Redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxy540843763/article/details/106600405
版权

文章目录

书接上回

上一篇文章 Redis的数据结构 string我们一起学习了这种类型的常用命令,并且还学习了 Redis中的字符串的结构表示以及好处，这里我们接着学习另外一种数据结构 list。

list 简介

list, 一般都会称为列表。在Redis中，这种数据结构是一种比较灵活的结构，由于其元素的是有序的，所以可以充当栈和队列这两种数据结构。实际在开发总也有很多应用场景。

一个List最多可以包含 2^32-1个元素。

很多人都会以为list是用数组来实现的，非也，非也。它内部是quicklist这种数据结构. 想要先睹为快的，那么坐电梯直达吧。

list的相关命令

LPUSH命令

  • 语法

LPUSH key value [value …]

  • 解释

lpush : left push。

将一个或者多个值插入到列表key的表头,返回列表的长度。元素可以是重复的。

如果key不存在，那么会先穿件一个列表，然后再执行push操作.

如果key值存在,但是value类型不是列表类型时，会返回一个错误。

  • 演示
# 设置一个列表
127.0.0.1:6379> LPUSH k22 v22
(integer) 1
# 查询指定区间内的数据,使用lrange命令
127.0.0.1:6379> LRANGE k22 0 10
1) "v22"
# 一次插入多个值
127.0.0.1:6379> LPUSH k22 v22_1 v22_2 v22_3 v22_4
(integer) 5
127.0.0.1:6379> LRANGE k22 0 10
1) "v22_4"
2) "v22_3"
3) "v22_2"
4) "v22_1"
5) "v22"

lpushx 命令

  • 语法

LPUSHX key value

  • 解释

仅当 key 存在的时候，才将 value 插入列表的表头。返回列表中元素的个数。

  • 演示
# 当key值不存在的时候，不会放入列表中
127.0.0.1:6379> LPUSHX k23 v23
(integer) 0
# 再次尝试放入，也不可以。
127.0.0.1:6379> LPUSHX k23 v23
(integer) 0
# 先往数组放入一个元素
127.0.0.1:6379> lpush k23 v23
(integer) 1
# 再次尝试使用lpushx放入数据
127.0.0.1:6379> LPUSHX k23 v23_1
(integer) 2
# 再次尝试使用lpushx放入数据
127.0.0.1:6379> LPUSHX k23 v23_2
(integer) 3
# 查看列表 k23 中的数据。注意：和插入的顺序是相反的。
127.0.0.1:6379> Lrange k23 0 -1
1) "v23_2"
2) "v23_1"
3) "v23"

rpush 命令

  • 语法

RPUSH key value [value ...]

  • 解释

rpush 就是right push。将一个或多个值 value 插入到列表 key 的表尾(最右边)。返回列表的长度。

如果 key 不存在的时候，会创建一个空列表，然后在执行 rpush 操作。

如果 key 存在，但是不是一个列表类型时，返回一个错误。

  • 演示
# 往列表中加入数据
127.0.0.1:6379> RPUSH k24 v24
(integer) 1
127.0.0.1:6379> RPUSH k24 v24_1 v25_2 v25_3
(integer) 4
127.0.0.1:6379> lrange k24 0 -1
1) "v24"
2) "v24_1"
3) "v25_2"
4) "v25_3"
# 演示 key 存在，但是不是一个列表类型
127.0.0.1:6379> set k24_1 v24_1
OK
127.0.0.1:6379> rpush k24_1 v24_1
(error) WRONGTYPE Operation against a key holding the wrong kind of value

rpushx 命令

  • 语法

rpushx key value

  • 解释

与 lpushx 类似，如果key不存在时，什么都不会操作。如果key存在，才会将元素添加到表尾。

  • 演示
# key不存在的时候，不会插入数据
127.0.0.1:6379> rpushx k25 v25
(integer) 0
# 先设置一个列表
127.0.0.1:6379> rpush k25 v25_1
(integer) 1
127.0.0.1:6379> rpushx k25 v25_2
(integer) 2
127.0.0.1:6379> rpushx k25 v25_3
(integer) 3
# 查看列表中的数据。注意和插入的顺序是一致的。
127.0.0.1:6379> lrange k25 0 -1
1) "v25_1"
2) "v25_2"
3) "v25_3"

lpop 命令

  • 语法

LPOP key

  • 解释

left pop;

移除并返回列表的头元素. 当key不存在的时候，返回nil

  • 演示
# key不存在的时候，返回nil
127.0.0.1:6379> LPOP k26
(nil)
# 设置一个列表，有三个元素
127.0.0.1:6379> lpush k26 v26_1 v26_2 v26_3
(integer) 3
# 查看列表中的元素
127.0.0.1:6379> lrange k26 0 -1
1) "v26_3"
2) "v26_2"
3) "v26_1"
# 依次pop出元素
127.0.0.1:6379> lpop k26
"v26_3"
127.0.0.1:6379> lpop k26
"v26_2"
127.0.0.1:6379> lpop k26
"v26_1"
127.0.0.1:6379> lpop k26
(nil)

tip： lpush + lpop => 栈, rpush + lpop => 队列。

rpop 命令

  • 语法

rpop key

  • 解释

rpop ： right pop;

和lpop相反。移除并返回列表的尾元素。如果key不存在返回 nil。

  • 演示
# key 不存在，返回nil
127.0.0.1:6379> rpop k27
(nil)
# 先设置一个列表
127.0.0.1:6379> lpush k27 v27_1 v27_2 v27_3
(integer) 3
127.0.0.1:6379> lrange k27 0 -1
1) "v27_3"
2) "v27_2"
3) "v27_1"
# 一次pop每个值
127.0.0.1:6379> rpop k27
"v27_1"
127.0.0.1:6379> rpop k27
"v27_2"
127.0.0.1:6379> rpop k27
"v27_3"
127.0.0.1:6379> rpop k27
(nil)

tip: lpush + rpop => 队列, rpush + rpop => 栈。

lrange 命令

  • 语法

LRANGE key start stop

  • 解释

获取指定区间内的元素。0表示第一个元素。如果超过了实际范围就返回空数组。

  • 演示
127.0.0.1:6379> LRANGE k22 0 10
1) "v22_4"
2) "v22_3"
3) "v22_2"
4) "v22_1"
5) "v22"
127.0.0.1:6379> LRANGE k22 0 1
1) "v22_4"
2) "v22_3"
127.0.0.1:6379> LRANGE k22 10 100
(empty list or set)

rpoplpush 命令

  • 语法

RPOPLPUSH source destination

  • 解释

将 source 的尾元素插入到destination列表的头元素中，返回该元素。 注意，这是一个原子操作。

比如: source: a,b,c

distination: 1,2,3

使用 RPOPLPUSH source distination ,则：

source: a,b

distination: c,1,2,3

  • 演示
# 设置列表1
127.0.0.1:6379> lpush k28_1 v28_c v28_b v28_a
(integer) 3
# 设置列表2
127.0.0.1:6379> lpush k28_2 v28_3 v28_2 v28_1
(integer) 3
# 使用 rpoppush命令
127.0.0.1:6379> RPOPLPUSH k28_1 k28_2
"v28_c"
# 查看列表1
127.0.0.1:6379> lrange k28_1 0 -1
1) "v28_a"
2) "v28_b"
# 查看列表2
127.0.0.1:6379> lrange k28_2 0 -1
1) "v28_c"
2) "v28_1"
3) "v28_2"
4) "v28_3"

lrem 命令

  • 语法

LREM key count value

  • 解释

至多移除列表中 count 个与参数 value 相等的元素。

有以下情況:

count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，最多移除count个 。

count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，最多移除|count|个。

count = 0 : 移除表中所有与 value 相等的值。

  • 演示
# 演示 count>0 时
# 设置一个列表
127.0.0.1:6379> lpush k29_1 v29_1  v29  v29_2 v29 v29_3 v29
(integer) 6
# 从表头开始，移除2个 v29
127.0.0.1:6379> lrem k29_1 2 v29
(integer) 2
127.0.0.1:6379> lrange k29_1 0 -1
1) "v29_3"
2) "v29_2"
3) "v29"
4) "v29_1"
# 演示count<0 时
127.0.0.1:6379> lpush k29_2 v29_1 v29  v29_2 v29 v29_3 v29
(integer) 6
127.0.0.1:6379> lrem k29_2 -2 v29
(integer) 2
127.0.0.1:6379> LRANGE k29_2 0 -1
1) "v29"
2) "v29_3"
3) "v29_2"
4) "v29_1"

# 演示count=0时
127.0.0.1:6379> lpush k29_3 v29_1 v29  v29_2 v29 v29_3 v29
(integer) 6
127.0.0.1:6379> lrem k29_3 0 v29
(integer) 3
127.0.0.1:6379> LRANGE k29_3 0 -1
1) "v29_3"
2) "v29_2"
3) "v29_1"

llen 命令

  • 语法

LLEN key

  • 解释

获取列表的长度。

如果 key 不存在的时候，返回0.

如果 key 对应类型不是 list ，则返回一个错误。

  • 演示
127.0.0.1:6379> llen k30
(integer) 0
127.0.0.1:6379> lpush k30 v30_1 v30_2
(integer) 2
127.0.0.1:6379> llen k30
(integer) 2

# 删掉k30，演示，类型不是list的时候，报错
127.0.0.1:6379> del k30
(integer) 1
127.0.0.1:6379> set k30 v30
OK
127.0.0.1:6379> llen k30
(error) WRONGTYPE Operation against a key holding the wrong kind of value

lindex 命令

  • 语法

lindex key index

  • 解释

返回列表中，下标为 index 的元素. -1 表示列表的最后一个元素, 如果key不存在,或者index超出范围，返回nil， 如果key不是一个列表类型, 返回一个错误。

  • 演示
127.0.0.1:6379> lpush k31 v31_3 v31_2 v31_1
(integer) 3
127.0.0.1:6379> LINDEX k31 2
"v31_3"
127.0.0.1:6379> LINDEX k31 1
"v31_2"
127.0.0.1:6379> LINDEX k31 0
"v31_1"

linsert 命令

  • 语法

linsert key BEFORE|AFTER pivot value

  • 解释

将value插入到key队列pivot值之前或者之后. 返回插入完成之后列表的长度。

如果 pivot 不存在 或者 key 不存在, 不执行任何操作。

如果 key 对应的不是一个列表类型, 返回一个错误。

  • 演示
127.0.0.1:6379> linsert k32 BEFORE k31_1 k31_0
(integer) 0
127.0.0.1:6379> lpush k32 v32_1
(integer) 1
# k32_3 => pivot不存在
127.0.0.1:6379> linsert k32 BEFORE v32_3 v31_2
(integer) -1
# pivot之前插入
127.0.0.1:6379> linsert k32 BEFORE v32_1 v31_0
(integer) 2
# pivot之后插入
127.0.0.1:6379> linsert k32 AFTER v32_1 v31_2
(integer) 3

lset 命令

  • 语法

lset key index value

  • 解释

将列表中的 索引为index的值设置为value。 如果index超出范围，则返回一个错误

  • 演示
127.0.0.1:6379> lpush k33 v33_3 v33_1
(integer) 2
127.0.0.1:6379> lrange k33 0 -1
1) "v33_1"
2) "v33_3"
## 将第二个值，索引为1，设置为v33_2
127.0.0.1:6379> lset k33 1 v33_2
OK
127.0.0.1:6379> lrange k33 0 -1
1) "v33_1"
2) "v33_2"

# 超出范围返回错误
127.0.0.1:6379> lset k33 2 v33_2
(error) ERR index out of range

ltrim 命令

  • 语法

ltrim key start stop

  • 解释

保留列表从start到stop之间的元素。其他元素都将被删除。 注意:包含(不删除)start和stop两个元素.

如果key不存在,直接返回OK, 如果key对应的不是列表，直接返回错误。

  • 演示
127.0.0.1:6379> lpush k34 v34_1 v34_2 v34_3 v34_4 v34_5 v34_6
(integer) 6
127.0.0.1:6379> ltrim k34 1 4
OK
127.0.0.1:6379> lrange k34  0 -1
1) "v34_5"
2) "v34_4"
3) "v34_3"
4) "v34_2"

blpop 命令

  • 语法

BLPOP key [key ...] timeout

  • 解释

lpop 的 阻塞版本。 block left pop

当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。

  • 演示
# push到三组列表，分别三个元素
127.0.0.1:6379> lpush k35 v35_1 v35_2 v35_3
(integer) 3
127.0.0.1:6379> lrange k35 0 -1
1) "v35_3"
2) "v35_2"
3) "v35_1"
127.0.0.1:6379> lpush k35_1 v35_1 v35_2 v35_3
(integer) 3
127.0.0.1:6379> lpush k35_2 v35_1 v35_2 v35_3
(integer) 3

# 阻塞调用lpop, 从左到右 依次pop元素，直到有一个元素可以pop。
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
1) "k35"
2) "v35_3"
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
1) "k35"
2) "v35_2"
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
1) "k35"
2) "v35_1"
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
1) "k35_1"
2) "v35_3"
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
1) "k35_1"
2) "v35_2"
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
1) "k35_1"
2) "v35_1"
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
1) "k35_2"
2) "v35_3"
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
1) "k35_2"
2) "v35_2"
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
1) "k35_2"
2) "v35_1"
127.0.0.1:6379> blpop k35 k35_1 k35_2 10
# 没有元素的时候会阻塞一直到超时。
(nil)
(10.59s)

brpop 命令

  • 语法

BRPOP key [key ...] timeout

  • 解释

rpop 的阻塞版本。 block right pop
当给定多个key的时候，按照key的先后顺序依次检查各个列表。直到弹出一个元素或者超时。

  • 演示
# 设置两个列表
127.0.0.1:6379> lpush k36 v36_1 v36_2 v36_3
(integer) 3
127.0.0.1:6379> lpush k36_1 v36_1 v36_2 v36_3
(integer) 3
# 阻塞式的pop出每个值。
127.0.0.1:6379> BRPOP k36 k36_1 10
1) "k36"
2) "v36_1"
127.0.0.1:6379> BRPOP k36 k36_1 10
1) "k36"
2) "v36_2"
127.0.0.1:6379> BRPOP k36 k36_1 10
1) "k36"
2) "v36_3"
127.0.0.1:6379> BRPOP k36 k36_1 10
1) "k36_1"
2) "v36_1"
127.0.0.1:6379> BRPOP k36 k36_1 10
1) "k36_1"
2) "v36_2"
127.0.0.1:6379> BRPOP k36 k36_1 10
1) "k36_1"
2) "v36_3"
127.0.0.1:6379> BRPOP k36 k36_1 10
# 阻塞10s
(nil)
(10.61s)

Tips: lpush + brpop => 阻塞队列。

brpoplpush 命令

  • 语法

BRPOPLPUSH source destination timeout

  • 解释

rpoplpush 的阻塞版本。 block right left push。

当列表 source 为空的时候，该命令将阻塞，直到超时,或者source中有一个元素可以pop。

  • 演示
# 设置一个列表
127.0.0.1:6379> lpush k37_source v37_1 v37_2 v37_3 v37_4
(integer) 4
# 将source移动到distination中。
127.0.0.1:6379> BRPOPLPUSH k37_source k37_distination 10
"v37_1"
# 查看下distination。
127.0.0.1:6379> lrange k37_distination 0 -1
1) "v37_1"
127.0.0.1:6379> BRPOPLPUSH k37_source k37_distination 10
"v37_2"
127.0.0.1:6379> BRPOPLPUSH k37_source k37_distination 10
"v37_3"
127.0.0.1:6379> BRPOPLPUSH k37_source k37_distination 10
"v37_4"

# 这时我们启动两个客户端,演示阻塞直到另一个客户端执行source列表中的插入操作。
# 客户端1中继续执行 BRPOPLPUSH, 然后马上在客户端2中，输入"LPUSH k37_source v37_5".

# 客户端1
127.0.0.1:6379> BRPOPLPUSH k37_source k37_distination 10
"v37_5"
(3.02s)
# 客户端2
127.0.0.1:6379> LPUSH k37_source v37_5
(integer) 1

list内部结构之quicklist

quicklist

我们来看一下list的内部实现 quicklist 结构.

特别注明： quicklist 是链表结构。

在Redis中使用如下结构体表示.

typedef struct quicklist {
    // 头结点
    quicklistNode *head;
    // 尾结点
    quicklistNode *tail;
    // 列表的元素个数
    unsigned long count;
    // 链表的长度
    unsigned long len;
    // 单个节点的填充因子
    int fill : 16;
    // 不进行节点压缩的最大深度
    // 超过这个节点就会进行节点压缩
    unsigned int compress : 16;
} quicklist;

quicklist是回一个通用的双向链接快速列表实现。它的每个节点用 quicklistNode 表示。

一起来看下 qucklistNode 是什么吧。

quicklistNode
typedef struct quicklistNode {
    // 前一个节点
    struct quicklistNode *prev;
    // 后一个节点
    struct quicklistNode *next;
    // 数据指针。
    // 如果指向的数据没有被压缩,那么会指向zipList结构。
    // 如果进行了压缩，那么会指向 quickLZF结构。
    unsigned char *zl;
    // 当前节点的大小
    unsigned int sz;
    // 元素的个数
    unsigned int count : 16;
    // 编码方式，1=RAW，2=LZF
    // 1 表示未被压缩
    // 2 表示使用LZF结构进行的压缩
    unsigned int encoding : 2;   
    // 使用的容器是什么？1=NONE,2=ZIPLIST
    unsigned int container : 2;
    // 前一个节点是否被压缩
    unsigned int recompress : 1; 
    // 是否压缩
    unsigned int attempted_compress : 1; 
    // 暂时留出来，以后使用。
    unsigned int extra : 10;
} quicklistNode;

quicklistNode是一个32byte的结构体，用于描述一个quicklist的一个节点。从代码中可看出，使用了位图来节约空间。在上面的代码中我们提到还提到两种数据结构 quicklistLZF和 ziplist.

ziplist

ziplist这种结构比较复杂，而且在源码中也没有给出明确定义。那 ziplist 这么神秘的结构到底是什么样的呢?

别着急, 我们先大体熟悉下ziplist这种结构的设计意图。

ziplist 是一个经过特殊编码的双向链表，它的设计意图就是 提高存储效率， ziplist可以用于存储字符串或者整数，其中整数是按照真正的二进制进行编码的。 它能以O(1) 的效率在表的两端进行pop和push操作。

我们都知道，普通的链表每项都是一块独立的内存空间，各项之间都是通过指针连接起来的。这种方式，会带来大量的空间碎片，指针引用也会占用部分空间内存。所以ziplist是将表中每项放在连续的空间内存中(类似数组)，ziplist还对值采取了一个可变长度的存储方式，大的值就用大空间，小的值就用小空间。

ziplist结构的官方定义。

The general layout of the ziplist is as follows:
<zlbytes> <zltail> <zllen> <entry> <entry> ... <entry> <zlend>
<uint32_t zlbytes> is an unsigned integer to hold the number of bytes that the ziplist occupies, including the four bytes of the zlbytes field itself. This value needs to be stored to be able to resize the entire structure without the need to traverse it first.
<uint32_t zltail> is the offset to the last entry in the list. This allows a pop operation on the far side of the list without the need for full traversal.
<uint16_t zllen> is the number of entries. When there are more than 2^16-2 entries, this value is set to 2^16-1 and we need to traverse the entire list to know how many items it holds.
<uint8_t zlend> is a special entry representing the end of the ziplist. Is encoded as a single byte equal to 255. No other normal entry starts with a byte set to the value of 255.

根据上面中解释我们可以得出以下这种模型：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IJar37ts-1591506025719)(./images/ziplist-01-Ziplist的结构.png)]

如果没有特殊指定的话, 都是采用小尾数法存储的。

  • zlbytes: 存储一个无符号整数，用于存储ziplist的所用的字节数,(包括zlbytes字段本身的四个字节)，当重新分配内容的时候，不需要遍历整个列表来计算内存大小。

  • zltail: 一个无符号整数，表示ziplist中最后一个元素的偏移字节数，这样可以方便的找到最后一个元素，从而可以以O(1)的复杂度在尾端进行pop和push。

  • zllen：压缩列表包含的结点的个数，即entry的个数。
    这里的zllen是占用16bit, 也就是说最多存储 2^16-2 个。但是ziplist超了2^16-2个也是可以表示的。那种情况就是16个1的时候，只需要从头遍历到尾就好了。

  • entry: 真正存放数据的数据项，每个数据项都有自己的内部结构。

  • zlend: ziplist的最后一个字节，值固定等于255，就是一个结束标记。

entry 结构

entry 是由三部分构成的。

  • previous length（pre_entry_length）： 表示前一个数据节点占用的总字节数，这个字段的用处是为了让ziplist能够从后向前遍历（从后一项的位置，只需向前偏移previous length个字节，就找到了前一项）。这个字段采用变长编码。

  • encoding（encoding&cur_entry_length）：表示当前数据节点content的内容类型以及长度。也采用变长编码。

  • entry-data：表示当前节点存储的数据，entry-data的内容类型有整数类型和字节数组类型，且某些条件下entry-data的长度可能为0。

所以我们可以得出 ziplist 是一个这样的结构。

在这里插入图片描述

有时，encoding也可以代表entry本身，就像小整数一样。
在这里插入图片描述

这里就是大体的了解下ziplist这种数据结构。

后面我们有一篇专门对ziplist这种数据结构解读的文章。

quicklistLZF

看完了比较神秘的ziplist 结构，我们来看一个比较简单的quicklist的压缩节点的结构 quicklistLZF。

/**
 * quicklistLZF是一个4 + N字节的 struct。
 * sz 是 compressed 字段的字节长度。'compressed' 是长度为 sz的 LZF数据。
 *
 * 未被压缩的长度保存到 quicklistNode->sz中。
 *
 * 当压缩了quicklistNode->zl时，quicklistNode->zl指向的是一个 quicklistLZF类型的数据。
 * 未压缩的时候，指向的是ziplist.
 */
typedef struct quicklistLZF {
    ///compressed数组长度 
    unsigned int sz; 
    char compressed[];
} quicklistLZF;

总结

  • list 相关的命令。以及常见的应用场景.比如栈和队列等等。
  • list 其实是一种链表结构,但是不是一个普通的链表结构。
  • list 是由 quicklist 这种数据结构实现的。quicklist 中的每个节点是quicklistNode, 而quicklist中zl指针，指向的是 一个ziplist。
  • ziplist是一个比较神秘的数据结构，有5部分构成，是连续存储的，可以实现O(1)的尾端pop和push操作。

最后

希望和你成为朋友！我们一起学习~
最新文章尽在公众号【方家小白】，期待和你相逢在【方家小白】

方_小_白
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Redis 数据结构1
08-03
Redis 是一个高性能的键值存储系统，它的数据结构设计是其高效性和灵活性的关键。Redis 的底层网络模型采用单线程配合epoll事件模型，这使得所有命令的执行是串行的，避免了多线程的上下文切换开销，但同时也意味着...
redis面试题之数据结构.zip
04-18
在面试中，Redis的数据结构是考察候选人技术深度的重要部分。以下将详细介绍Redis中的主要数据结构及其应用。 1. 字符串（String） Redis中的字符串是最基本的数据类型，可以存储任何可打印的字符序列，包括整数和...
Redis数据结构：List类型全面解析
栗筝i的博客
08-23 4650
Redis 中列表（List）类型是用来存储多个有序的字符串，列表中的每个字符串成为元素 Eelement），一个列表最多可以存储 2^32-1 个元素。 在 Redis 中，可以对列表两端插入（push）和弹出（pop），还可以获取指定范围的元素列表、获取指定索引下标的元素等。列表是一种比较灵活的数据结构，可以充当栈和队列的角色，在实际开发中有很多应用场景。
【Redis】数据结构 - List
比嗨皮兔
04-05 976
其中，lpush 和 rpush 命令用于在 List 的左侧和右侧插入一个或多个元素，linsert 命令用于在指定元素前或后插入一个新元素，lpop 和 rpop 命令分别用于删除 List 的左侧和右侧的元素。需要注意的是，在使用 Redis 的 List 数据结构时，应根据实际情况选择合适的命令和操作方法，并注意数据类型转换和内存管理等问题。需要注意的是，在使用 Redis 的 List 数据结构时，应根据实际情况选择合适的命令和操作方法，并注意数据类型转换和内存管理等问题。
Redis 中 List 数据结构详解
最新发布
llt2997632602的博客
05-28 919
Reids 中 List 的常用命令，编码，场景整理。
redis list底层数据结构
meser88的博客
10-28 3544
redis list数据结构  redis list数据结构底层采用压缩列表ziplist或linkedlist两种数据结构进行存储，首先以ziplist进行存储，在不满足ziplist的存储要求后转换为linkedlist列表。  当列表对象同时满足以下两个条件时，列表对象使用ziplist进行存储，否则用linkedlist存储。 列表对象保存的所有字符串元素的长度小于64字节 列表对象保存的元素数量小于512个。 redis list元素添加过程  list的数据添加根据传入的变量个数一个个顺
02-Redis数据结构-List
weixin_37862824的博客
05-19 1830
Redis列表list 底层原理 在版本3.2之前，Redis 列表list使用两种数据结构作为底层实现： 压缩列表ziplist 双向链表linkedlist 因为双向链表占用的内存比压缩列表要多， 所以当创建新的列表键时， 列表会优先考虑使用压缩列表， 并且在有需要的时候， 才从压缩列表实现转换到双向链表实现。 压缩列表转化成双向链表 创建新列表时 redis 默认使用 redis_encoding_ziplist 编码， 当以下任意一个条件被满足时， 列表会被转换成redis_encodin
redis-----03-----redis-list结构以及应用
weixin_44517656的博客
02-23 846
1 list 首尾相接的双向链表，链表首尾操作时间复杂度为O(1) ；查找中间元素时间复杂度为 ；O(n)。 列表中数据可能会被压缩： 元素长度小于 48，不压缩。 元素压缩前后长度差不超过 8，不压缩。例如压缩前大小是60，压缩后大小是56，那么不会压缩。 所以一个占用内存很大答结构，可能会被redis压缩成多个ziplist，即quicklist。 具体压缩后如何提高性能，可以看回这篇文章：redis-----01-----redis介绍(redis安装下载、底层存储结构原理剖析) 2 基础命令
Redis List 数据结构的优越感
01-07
Redis List 实现负载均衡 前言 需求 业务需求：从1000条用户登录记录中选择最新登录的前5个用户 PS：（默认使用mysql数据库） select * from user order by loginTime desc limit 5 为了解决查询效率，你可能会设置...
Redis之基本数据结构
01-20
相当于LinkedList队列-右边进左边出栈-右边进右边出ltrim截取hash字典-相当于hashmapset集合-相当于hashSetzset有序集合-相当于sortedSet容器型数据结构通用规则 如果不能深入地了解系统，技术和框架背后的深层原理...
详解redis数据结构之压缩列表
09-09
然而，当entry数量增加或者数据变大时，压缩列表的效率可能会下降，此时Redis会切换到更复杂的数据结构，如字典（dict）或双向链表（linked list）。 理解压缩列表的工作原理对于优化Redis的内存使用和性能至关重要...
【Redis】redis基本数据结构之List
weixin_33919950的博客
06-24 292
简介： Redis中的List数据结构是链表型的，类似于LinkedList。所以它的插入效率非常高，时间复杂度为O(1)。它的查询效率较慢，时O(n)。 但其实Redis内部，list结构又不是一个简单的链表，因为LinkedList的每一个节点都要保存上一个节点和下一个节点的指针，相对来说比数组型的列表更占空间。在Redis中，有一种压缩列表的存在zipList，它把少量的元素使用一个连续...
Redis数据类型--List类型详解及应用
weixin_42118323的博客
02-26 2209
概述：list类型可以存储一个有序的字符串列表，为了方便理解我把他类比于于Java中的LinkedList（双向链表），既然是链表，那就可以链表两端快速插入或删除，因为是双向链表结构，就注定了查询较慢。Redis无论什么数据类型，存储的时候都是以键值对key-value形势存储，并且所有的key都是String类型，本文讨论的数据类型是value的数据类型。如有不正确的地方请各位指出纠正。
Redis的list数据结构 lpush、rpush、lpop、rpop等常用操作
热门推荐
mengqingming1的博客
11-21 2万+
lpush 添加一个或多个元素插入到list的头部 lpush key [values...] 127.0.0.1:6379> lpush mylist java c++ c (integer) 3 127.0.0.1:6379> lrange mylist 0 -1 1) "c" 2) "c++" 3) "java" lpop 从 list 中删除并返回第一个元素 lpop k...
Redis对象——列表(list)
Oh~Why not!
06-09 3400
提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具...
Redis 五种常见的数据结构：List
02-19 1419
Redis 五种常见的数据结构：List
redis中的数据结构之list列表
dabiaoge33的博客
12-28 200
redis中的数据结构之list列表 1、list命令介绍。 RPUSH：将给定值推入列表的右端。 LPUSH：将给定值推入列表的左端。 LRANGE：获取列表在给定范围上的所有值。 LINDEX：获取列表在给定位置上的单个元素。 LPOP：从列表的左端移除一个值，并返回被移除的值。 示例如下： -------------------向列表右端推入值 127.0.0.1:6379...
redis的数据结构——存储list
玉爷的博客
04-16 9847
在Redis中，List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表 一样，我们可以在其头部(left)和尾部(right)添加新的元素。在插入时，如果该键并不 存在，Redis将为该键创建一个新的链表。与此相反，如果链表中所有的元素均被移 除，那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是 4294967295。 1、两端添加 ● lpush key v...
redis数据结构list
09-08
Redis的数据结构之一是列表（List），它支持在列表的两端进行元素的插入和删除操作，提供了丰富的操作方法。 你可以使用以下命令在Redis中操作列表数据结构： 1. LPUSH key value1 [value2 ...]: 将一个或多个值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

方_小_白

谢谢金主子，记得关注方家小白哦

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值