【Redis 常见的5种数据类型】List | Set

文章目录

@[toc]

1 :peach:List:peach:
1.1 :apple:lpush:apple:
1.2 :apple:lpushx:apple:
1.3 :apple:rpush:apple:
1.4 :apple:rpushx:apple:
1.5 :apple:lrange:apple:
1.6 :apple:lpop:apple:
1.7 :apple:rpop:apple:
1.8 :apple:lindex:apple:
1.9 :apple:linsert:apple:
1.10 :apple:len:apple:
1.11 :apple:blpop:apple:
1.12 :apple:brpop:apple:
1.13 :apple:内部编码:apple:
1.14 :apple:使⽤场景:apple:
1.14.1 :lemon:消息队列:lemon:
1.14.2 :lemon:微博 Timeline:lemon:

2 :peach:Set:peach:
2.1 :apple:sadd:apple:
2.2 :apple:smembers:apple:
2.3 :apple:sismember:apple:
2.4 :apple:scard:apple:
2.5 :apple:spop:apple:
2.6 :apple:smove:apple:
2.7 :apple:srem:apple:
2.8 :apple:sinter:apple:
2.9 :apple:sinterstore:apple:
2.10 :apple:sunion:apple:
2.11 :apple:sunionstore:apple:
2.12 :apple:sdiff:apple:
2.13 :apple:sdiffstore:apple:
2.14 :apple:内部编码:apple:
2.15 :apple:使⽤场景:apple:

3 :peach:Zset:peach:
3.1 :apple:zadd:apple:
3.2 :apple:zcard:apple:
3.3 :apple:zcount:apple:
3.4 :apple:zrange:apple:
3.5 :apple:zrevrange:apple:
3.6 :apple:zrangebyscore:apple:
3.7 :apple:zpopmax:apple:
3.8 :apple:bzpopmax:apple:
3.9 :apple:zpopmin:apple:
3.10 :apple:bzpopmin:apple:
3.11 :apple:zrank:apple:
3.12 :apple:revrank:apple:
3.13 :apple:zscore:apple:
3.14 :apple:zrem:apple:
3.15 :apple:zremrangebyrank:apple:
3.16 :apple:zremrangebyscore:apple:
3.17 :apple:zincrby:apple:
3.18 :apple:zinterstore:apple:
3.19 :apple:zunionstore:apple:
3.20 :apple:内部编码:apple:
3.21 :apple:使用场景:apple:

1 🍑List🍑

列表类型是⽤来存储多个有序的字符串，如图所⽰，a、b、c、d、e 五个元素从左到右组成了⼀个有序的列表，列表中的每个字符串称为元素（element），⼀个列表最多可以存储个元素。
在这里插入图片描述

在 Redis 中，可以对列表两端插⼊（push）和弹出（pop），还可以获取指定范围的元素列表、获取指定索引下标的元素等。列表是⼀种⽐较灵活的数据结构，它可以充当栈。

注意：列表元素是允许重复的，并且列表是讲究顺序的。讲究顺序也就是{1，2，3}和{1，3，2}是两个完全不同的列表。

1.1 🍎lpush🍎

将⼀个或者多个元素从左侧放⼊（头插）到 list 中。
语法：

LPUSH key element [element ...]

命令有效版本：1.0.0 之后
时间复杂度：只插⼊⼀个元素为 O(1), 插⼊多个元素为 O(N), N 为插⼊元素个数.
返回值：插⼊后 list 的⻓度。
⽰例：
在这里插入图片描述

1.2 🍎lpushx🍎

在 key 存在时，将⼀个或者多个元素从左侧放⼊（头插）到 list 中。不存在，直接返回。
语法：

LPUSHX key element [element ...]

命令有效版本：2.0.0 之后
时间复杂度：只插⼊⼀个元素为 O(1), 插⼊多个元素为 O(N), N 为插⼊元素个数.
返回值：插⼊后 list 的⻓度。
⽰例：
在这里插入图片描述

1.3 🍎rpush🍎

将⼀个或者多个元素从右侧放⼊（尾插）到 list 中。
语法：

RPUSH key element [element ...]

命令有效版本：1.0.0 之后
时间复杂度：只插⼊⼀个元素为 O(1), 插⼊多个元素为 O(N), N 为插⼊元素个数.
返回值：插⼊后 list 的⻓度。
用法与lpush基本类似，这里就不再演示了。

1.4 🍎rpushx🍎

在 key 存在时，将⼀个或者多个元素从右侧放⼊（尾插）到 list 中。
语法：

RPUSHX key element [element ...]

命令有效版本：2.0.0 之后
时间复杂度：只插⼊⼀个元素为 O(1), 插⼊多个元素为 O(N), N 为插⼊元素个数.
返回值：插⼊后 list 的⻓度。

1.5 🍎lrange🍎

获取从 start 到 end 区间的所有元素，左闭右闭。
语法：

 LRANGE key start stop

命令有效版本：1.0.0 之后
时间复杂度：O(N)
返回值：指定区间的元素。
⽰例：
在这里插入图片描述

1.6 🍎lpop🍎

从 list 左侧取出元素（即头删）。
语法：

LPOP key

命令有效版本：1.0.0 之后
时间复杂度：O(1)
返回值：取出的元素或者 nil。
⽰例：
在这里插入图片描述

1.7 🍎rpop🍎

从 list 右侧取出元素（即尾删）。
语法：

RPOP key

命令有效版本：1.0.0 之后
时间复杂度：O(1)
返回值：取出的元素或者 nil。

1.8 🍎lindex🍎

获取从左数第 index 位置的元素。
语法：

LINDEX key index

命令有效版本：1.0.0 之后
时间复杂度：O(N)
返回值：取出的元素或者 nil。
⽰例：
在这里插入图片描述

1.9 🍎linsert🍎

在特定位置插⼊元素。
语法：

 LINSERT key <BEFORE | AFTER> pivot element

命令有效版本：2.2.0 之后
时间复杂度：O(N)
返回值：插⼊后的 list ⻓度。
⽰例：
在这里插入图片描述

1.10 🍎len🍎

获取 list ⻓度。
语法：

 LLEN key

命令有效版本：1.0.0 之后
时间复杂度：O(1)
返回值：list 的⻓度。
⽰例：
在这里插入图片描述

1.11 🍎blpop🍎

lpop 的阻塞版本。
语法：

BLPOP key [key ...] timeout

命令有效版本：1.0.0 之后
时间复杂度：O(1)
返回值：取出的元素或者 nil。

⽰例：

在列表中有元素的情况下，阻塞和⾮阻塞表现是⼀致的。但如果列表中没有元素，⾮阻塞版本会立马返回 nil，但阻塞版本会根据 timeout，阻塞⼀段时间，期间 Redis 可以执⾏其他命令，但要求执⾏该命令的客⼾端会表现为阻塞状态。
命令中如果设置了多个键，那么会从左向右进⾏遍历键，⼀旦有⼀个键对应的列表中可以弹出元素，命令⽴即返回。
如果多个客⼾端同时多⼀个键执⾏ pop，则最先执⾏命令的客⼾端会得到弹出的元素。这个我就不验证了大家可以自行验证。

1.12 🍎brpop🍎

RPOP 的阻塞版本。
语法：

BRPOP key [key ...] timeout

命令有效版本：1.0.0 之后
时间复杂度：O(1)
返回值：取出的元素或者 nil。
用法与blpop基本类似。

1.13 🍎内部编码🍎

列表类型的内部编码有3种：

ziplist（压缩列表）：当列表的元素个数⼩于 list-max-ziplist-entries 配置（默认 512 个），同时列表中每个元素的⻓度都⼩于 list-max-ziplist-value 配置（默认 64 字节）时，Redis 会选⽤ziplist 来作为列表的内部编码实现来减少内存消耗。
linkedlist（链表）：当列表类型⽆法满⾜ ziplist 的条件时，Redis 会使⽤ linkedlist 作为列表的内部实现。
quicklist：结合了 ziplist 和 linkedlist 两者的优势，为列表类型提供了⼀种更为优秀的内部编码实现。

注意：较新版本的 Redis 都是使用的quicklist编码。

在这里插入图片描述

1.14 🍎使⽤场景🍎

1.14.1 🍋消息队列🍋

Redis 可以使⽤ lpush + brpop 命令组合实现经典的阻塞式⽣产者-消费者模型队列，⽣产者客⼾端使⽤ lpush 从列表左侧插⼊元素，多个消费者客⼾端使⽤ brpop 命令阻塞式地从队列中"争抢" 队⾸元素。通过多个客⼾端来保证消费的负载均衡和⾼可⽤性。

注意：但是一般场景下我们不会使用List来作为消息队列，而是使用功能更加强大的Streams。

1.14.2 🍋微博 Timeline🍋

每个⽤⼾都有属于⾃⼰的 Timeline（微博列表），现需要分⻚展⽰⽂章列表。此时可以考虑使⽤列表，因为列表不但是有序的，同时⽀持按照索引范围获取元素。

选择列表类型时，请参考：
同侧存取（lpush + lpop 或者 rpush + rpop）为栈
异侧存取（lpush + rpop 或者 rpush + lpop）为队列

2 🍑Set🍑

集合类型也是保存多个字符串类型的元素的，但和列表类型不同的是，在集合中：
1）元素之间是⽆序的；
2）元素不允许重复。1个集合中最多可以存储 2³²-1 个元素。Redis 除了⽀持集合内的增删查改操作，同时还⽀持多个集合取交集、并集、差集，合理地使⽤好集合类型，能在实际开发中解决很多问题。

2.1 🍎sadd🍎

将⼀个或者多个元素添加到 set 中。注意，重复的元素⽆法添加到 set 中。
语法：

SADD key member [member ...]

命令有效版本：1.0.0 之后
时间复杂度：O(1)
返回值：本次添加成功的元素个数。
⽰例：
在这里插入图片描述

2.2 🍎smembers🍎

获取⼀个 set 中的所有元素，注意，元素间的顺序是⽆序的。
语法：

SMEMBERS key

命令有效版本：1.0.0 之后
时间复杂度：O(N)
返回值：所有元素的列表。
⽰例：
在这里插入图片描述

2.3 🍎sismember🍎

判断⼀个元素在不在 set 中。
语法：

SISMEMBER key member

命令有效版本：1.0.0 之后
时间复杂度：O(1)
返回值：1 表⽰元素在 set 中。0 表⽰元素不在 set 中或者 key 不存在。
⽰例：
在这里插入图片描述

2.4 🍎scard🍎

获取⼀个 set 的基数（cardinality），即 set 中的元素个数。
语法：

SCARD key

命令有效版本：1.0.0 之后
时间复杂度：O(1)
返回值：set 内的元素个数。
⽰例：
在这里插入图片描述

2.5 🍎spop🍎

从 set 中随机删除并返回⼀个或者多个元素。
语法：

 SPOP key [count]

命令有效版本：1.0.0 之后
时间复杂度：O(N), n 是 count
返回值：取出的元素。
⽰例：
在这里插入图片描述

2.6 🍎smove🍎

将⼀个元素从源 set 取出并放⼊⽬标 set 中。
语法：

SMOVE source destination member

命令有效版本：1.0.0 之后
时间复杂度：O(1)
返回值：1 表⽰移动成功，0 表⽰失败。
⽰例：
在这里插入图片描述

2.7 🍎srem🍎

将指定的元素从 set 中删除。
语法：

SREM key member [member ...]

命令有效版本：1.0.0 之后
时间复杂度：O(N), N 是要删除的元素个数.
返回值：本次操作删除的元素个数。
⽰例：
在这里插入图片描述

2.8 🍎sinter🍎

获取给定 set 的交集中的元素。
语法：

SINTER key [key ...]

命令有效版本：1.0.0 之后
时间复杂度：O(N * M), N 是最⼩的集合元素个数. M 是最⼤的集合元素个数.
返回值：交集的元素。
⽰例：
在这里插入图片描述

2.9 🍎sinterstore🍎

获取给定 set 的交集中的元素并保存到⽬标 set 中。
语法：

SINTERSTORE destination key [key ...]

命令有效版本：1.0.0 之后
时间复杂度：O(N * M), N 是最⼩的集合元素个数. M 是最⼤的集合元素个数.
返回值：交集的元素个数。
⽰例：
在这里插入图片描述

2.10 🍎sunion🍎

获取给定 set 的并集中的元素。
语法：

SUNION key [key ...]

命令有效版本：1.0.0 之后
时间复杂度：O(N), N 给定的所有集合的总的元素个数.
返回值：并集的元素。
⽰例：
在这里插入图片描述

2.11 🍎sunionstore🍎

获取给定 set 的并集中的元素并保存到⽬标 set 中。
语法：

SUNIONSTORE destination key [key ...]

命令有效版本：1.0.0 之后
时间复杂度：O(N), N 给定的所有集合的总的元素个数.
返回值：并集的元素个数。

2.12 🍎sdiff🍎

获取给定 set 的差集中的元素。
语法：

SDIFF key [key ...]

命令有效版本：1.0.0 之后
时间复杂度：O(N), N 给定的所有集合的总的元素个数.
返回值：差集的元素。
⽰例：
在这里插入图片描述

2.13 🍎sdiffstore🍎

获取给定 set 的差集中的元素并保存到⽬标 set 中。
语法：

SDIFFSTORE destination key [key ...]

命令有效版本：1.0.0 之后
时间复杂度：O(N), N 给定的所有集合的总的元素个数.
返回值：差集的元素个数。

2.14 🍎内部编码🍎

集合类型的内部编码有两种:

intset（整数集合）：当集合中的元素都是整数并且元素的个数⼩于 set-max-intset-entries 配置（默认 512 个）时，Redis 会选⽤ intset 来作为集合的内部实现，从⽽减少内存的使⽤。
hashtable（哈希表）：当集合类型⽆法满⾜ intset 的条件时，Redis 会使⽤ hashtable 作为集合的内部实现。
1）当元素个数较少并且都为整数时，内部编码为 intset;

2）当元素个数超过 512 个，内部编码为 hashtable;
3）当存在元素不是整数时，内部编码为 hashtable;

2.15 🍎使⽤场景🍎

集合类型⽐较典型的使⽤场景是标签（tag）。例如 A ⽤⼾对娱乐、体育板块⽐较感兴趣，B ⽤⼾对历史、新闻⽐较感兴趣，这些兴趣点可以被抽象为标签。有了这些数据就可以得到喜欢同⼀个标签的⼈，以及⽤⼾的共同喜好的标签，这些数据对于增强⽤⼾体验和⽤⼾黏度都⾮常有帮助。例如⼀个电⼦商务⽹站会对不同标签的⽤⼾做不同的产品推荐。

3 🍑Zset🍑

有序集合相对于字符串、列表、哈希、集合来说会有⼀些陌⽣。它保留了集合不能有重复成员的特点，但与集合不同的是，有序集合中的每个元素都有⼀个唯⼀的浮点类型的分数（score）与之关联，着使得有序集合中的元素是可以维护有序性的，但这个有序不是⽤下标作为排序依据⽽是⽤这个分数。

有序集合提供了获取指定分数和元素范围查找、计算成员排名等功能，合理地利⽤有序集合，可以帮助我们在实际开发中解决很多问题。

注意：有序集合中的元素是不能重复的，但分数允许重复。类⽐于⼀次考试之后，每个⼈⼀定有⼀个唯⼀的分数，但分数允许相同。

3.1 🍎zadd🍎

添加或者更新指定的元素以及关联的分数到 zset 中，分数应该符合 double 类型，+inf 和 -inf 作为正负极限也是合法的。
ZADD 的相关选项：

XX：仅仅⽤于更新已经存在的元素，不会添加新元素。
NX：仅⽤于添加新元素，不会更新已经存在的元素。
CH：默认情况下，ZADD 返回的是本次添加的元素个数，但指定这个选项之后，就会还包含本次更新的元素的个数。
INCR：此时命令类似 ZINCRBY 的效果，将元素的分数加上指定的分数。此时只能指定⼀个元素和分数。
LT：仅当新分数小于当前分数时才更新现有元素。此标志不会阻止添加新元素。
GT：仅当新分数大于当前分数时才更新现有元素。此标志不会阻止添加新元素。
语法：

ZADD key [NX | XX] [GT | LT] [CH] [INCR] score member [score member ...]

命令有效版本：1.2.0 之后
时间复杂度：O(log(N))
返回值：本次添加成功的元素个数。

注意：增加指定元素时score是在member前面的。

⽰例：
在这里插入图片描述
此时我们观察出现了出现了十六进制的数据，当我们重新启动Redis客户端并且带上--raw就可以解决：

接下来我们验证下XX与`NX选项：

另外当我们带上CH选项时会直接返回修改数据的个数：
在这里插入图片描述

接下来我们验证下LT与GT选项：
在这里插入图片描述

3.2 🍎zcard🍎

获取⼀个 zset 的基数（cardinality），即 zset 中的元素个数。
语法：

ZCARD key

命令有效版本：1.2.0 之后
时间复杂度：O(1)
返回值：zset 内的元素个数。
⽰例：
在这里插入图片描述

3.3 🍎zcount🍎

返回分数在 min 和 max 之间的元素个数，默认情况下，min 和 max 都是包含的，可以通过(排除。
语法：

ZCOUNT key min max

命令有效版本：2.0.0 之后
时间复杂度：O(log(N))
返回值：满⾜条件的元素列表个数。
⽰例：
在这里插入图片描述

3.4 🍎zrange🍎

返回指定区间⾥的元素，分数按照升序。带上 WITHSCORES 可以把分数也返回。
语法：

ZRANGE key start stop [WITHSCORES]

注意：此处的 [start, stop] 为下标构成的区间. 从 0 开始, ⽀持负数.

命令有效版本：1.2.0 之后
时间复杂度：O(log(N)+M)
返回值：区间内的元素列表。
⽰例：

3.5 🍎zrevrange🍎

返回指定区间⾥的元素，分数按照降序。带上 WITHSCORES 可以把分数也返回。
备注：这个命令可能在 6.2.0 之后废弃，并且功能合并到 ZRANGE 中。
语法：

ZREVRANGE key start stop [WITHSCORES]

命令有效版本：1.2.0 之后
时间复杂度：O(log(N)+M)
返回值：区间内的元素列表。
⽰例：
在这里插入图片描述

3.6 🍎zrangebyscore🍎

返回分数在 min 和 max 之间的元素，默认情况下，min 和 max 都是包含的，可以通过(排除。
备注：这个命令可能在 6.2.0 之后废弃，并且功能合并到 ZRANGE 中。
语法：

ZRANGEBYSCORE key min max [WITHSCORES]

命令有效版本：1.0.5 之后
时间复杂度：O(log(N)+M)
返回值：区间内的元素列表。
⽰例：
在这里插入图片描述

3.7 🍎zpopmax🍎

删除并返回分数最⾼的 count 个元素。
语法：

ZPOPMAX key [count]

命令有效版本：5.0.0 之后
时间复杂度：O(log(N) * M)
返回值：分数和元素列表。
⽰例：
在这里插入图片描述
但是如果有多个分数相同的删除的是哪个呢？我们来验证下：

我们发现删除的是字典序大的那个。(two > grm)

3.8 🍎bzpopmax🍎

ZPOPMAX 的阻塞版本。
语法：

BZPOPMAX key [key ...] timeout

命令有效版本：5.0.0 之后
时间复杂度：O(log(N))
返回值：元素列表。
⽰例：
终端1：
在这里插入图片描述
终端2：

3.9 🍎zpopmin🍎

删除并返回分数最低的 count 个元素。
语法：

ZPOPMIN key [count]

命令有效版本：5.0.0 之后
时间复杂度：O(log(N) * M)
返回值：分数和元素列表。
⽰例：
在这里插入图片描述
但是如果有多个分数相同的删除的是哪个呢？我们来验证下：

我们发现删除的是字典序小的那个。(two > grm)

3.10 🍎bzpopmin🍎

ZPOPMIN 的阻塞版本。
语法：

BZPOPMIN key [key ...] timeout

命令有效版本：5.0.0 之后
时间复杂度：O(log(N))
返回值：元素列表。

3.11 🍎zrank🍎

返回指定元素的排名，升序。
语法：

ZRANK key member

命令有效版本：2.0.0 之后
时间复杂度：O(log(N))
返回值：排名。
⽰例：
在这里插入图片描述

3.12 🍎revrank🍎

返回指定元素的排名，降序。
语法：

 ZREVRANK key member

命令有效版本：2.0.0 之后
时间复杂度：O(log(N))
返回值：排名。
⽰例：
在这里插入图片描述

3.13 🍎zscore🍎

返回指定元素的分数。
语法：

ZSCORE key member

命令有效版本：1.2.0 之后
时间复杂度：O(1)
返回值：分数。
⽰例：
在这里插入图片描述

3.14 🍎zrem🍎

删除指定的元素。
语法：

ZREM key member [member ...]

命令有效版本：1.2.0 之后
时间复杂度：O(M*log(N))
返回值：本次操作删除的元素个数。
⽰例：
在这里插入图片描述

3.15 🍎zremrangebyrank🍎

按照排序，升序删除指定范围的元素，左闭右闭。
语法：

ZREMRANGEBYRANK key start stop

命令有效版本：2.0.0 之后
时间复杂度：O(log(N)+M)
返回值：本次操作删除的元素个数。
⽰例：
在这里插入图片描述

3.16 🍎zremrangebyscore🍎

按照分数删除指定范围的元素，左闭右闭。
语法：

ZREMRANGEBYSCORE key min max

命令有效版本：1.2.0 之后
时间复杂度：O(log(N)+M)
返回值：本次操作删除的元素个数。
⽰例:
在这里插入图片描述

3.17 🍎zincrby🍎

为指定的元素的关联分数添加指定的分数值。
语法：

ZINCRBY key increment member

命令有效版本：1.2.0 之后
时间复杂度：O(log(N))
返回值：增加后元素的分数。
⽰例：
在这里插入图片描述

3.18 🍎zinterstore🍎

求出给定有序集合中元素的交集并保存进⽬标有序集合中，在合并过程中以元素为单位进⾏合并，元素对应的分数按照不同的聚合⽅式和权重得到新的分数。
语法：

ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight[weight ...]] [AGGREGATE <SUM | MIN | MAX>]

注意：这里面的numkeys代表合并有序集合的个数，weight代表权值，后面的SUM/MIN/MAX任选一个进行处理即可，默认不写是SUM。

命令有效版本：2.0.0 之后
时间复杂度：O(NK)+O(Mlog(M)) N 是输⼊的有序集合中, 最⼩的有序集合的元素个数; K 是输⼊了⼏个有序集合; M 是最终结果的有序集合的元素个数。
返回值：⽬标集合中的元素个数
⽰例：
在这里插入图片描述

3.19 🍎zunionstore🍎

求出给定有序集合中元素的并集并保存进⽬标有序集合中，在合并过程中以元素为单位进⾏合并，元素对应的分数按照不同的聚合⽅式和权重得到新的分数。
语法：

ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight[weight ...]] [AGGREGATE <SUM | MIN | MAX>]

命令有效版本：2.0.0 之后
时间复杂度：O(N)+O(M*log(M)) N 是输⼊的有序集合总的元素个数; M 是最终结果的有序集合的元素
个数.
返回值：⽬标集合中的元素个数

⽰例：
在这里插入图片描述

3.20 🍎内部编码🍎

有序集合类型的内部编码有两种：

ziplist（压缩列表）：当有序集合的元素个数⼩于 zset-max-ziplist-entries 配置（默认 128 个），同时每个元素的值都⼩于 zset-max-ziplist-value 配置（默认 64 字节）时，Redis 会⽤ ziplist 来作为有序集合的内部实现，ziplist 可以有效减少内存的使⽤。
skiplist（跳表）：当 ziplist 条件不满⾜时，有序集合会使⽤ skiplist 作为内部实现，因为此时ziplist 的操作效率会下降。

1）当元素个数较少且每个元素较⼩时，内部编码为 ziplist。
2）当元素个数超过 128 个，内部编码 skiplist。
3）当某个元素⼤于 64 字节时，内部编码 skiplist。