CentOS7-Redis常用五大数据类型

CentOS7-Redis常用五大数据类型

Redis键（key）

命令	作用
key *	查看当前库所有key
exists key	判断某个key是否存在
type key	查看key的类型
del key	删除指定的key数据（直接删除）
unlink key	根据 value选择非阻塞删除（异步删除），仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作
expire key 过期数值（秒）	给定的key设置过期时间，单位：秒
ttl key	查看key还有几秒过期，-1：永不过期，-2：已过期
select	切换数据库
dbsize	查看当前数据库的key的数量
flushdb	清除当前库
flushall	清除全部库

1、keys * 查看当前库中key的数量

1、使用客户端命令进入Redis
redis-cli

2、写值
set k1 v1
set k2 v2
set k3 v3

3、使用 keys * 查看当前库有多少个key
keys *

2、exists key 判断key是否存在

1、当前库中存在的key情况
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"

2、判断一个已经存在的key
127.0.0.1:6379> exists k3
(integer) 1


3、判断一个不存在的key
127.0.0.1:6379> exists k4
(integer) 0

3、type key 查看key的类型

1、当前库中存在的key情况
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"

2、查看 k2是什么类型
127.0.0.1:6379> type k2
string

4、del key 和 unlink key 删除key和value值

• del key

1、当前库中存在的key情况
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"

2、删除指定的key数据：k2
127.0.0.1:6379> del k2
(integer) 1

3、查看当前库删除k2后的key数量
127.0.0.1:6379> keys *
1) "k1"
2) "k3"

• unlink key

1、当前库中存在的key情况
127.0.0.1:6379> keys *
1) "k1"
2) "k3"

2、删除指定的key数据：k1
127.0.0.1:6379> unlink k1
(integer) 1

3、查看当前库删除k1后的key数量
127.0.0.1:6379> keys *
1) "k3"

5、expire key 过期数值（秒）和 ttl key 设置key过期时间和查看过期时间

1、当前库中存在的key情况
127.0.0.1:6379> keys *
1) "k3"

2、设置 k3 十秒后过期
127.0.0.1:6379> expire k3 10
(integer) 1

3、查看过期时间
127.0.0.1:6379> ttl k3
(integer) 6
127.0.0.1:6379> ttl k3
(integer) 4
127.0.0.1:6379> ttl k3
(integer) 2
127.0.0.1:6379> ttl k3
(integer) -2 （-2表示：已过期；-1表示：永不过期）

4、新加的key，默认是-1表示：永不过期
127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> ttl k1
(integer) -1

6、select 切换数据库

1、Redis中默认有16个库（0-15）
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> select 15
OK
127.0.0.1:6379[15]> select 11
OK
127.0.0.1:6379[11]> select 16
(error) ERR DB index is out of range
127.0.0.1:6379[11]> select 0
OK
127.0.0.1:6379>

7、dbsize 查看当前数据库的key数量

1、当前库中存在的key情况
127.0.0.1:6379> keys *
1) "k1"

2、查看当前数据库的key数量
127.0.0.1:6379> dbsize
(integer) 1

8、flushdb 清空当前库

1、当前库中存在的key情况
127.0.0.1:6379> keys *
1) "k1"

2、清空当前库的数据
127.0.0.1:6379> flushdb
OK

3、再次查看当前库中的key情况
127.0.0.1:6379> keys *
(empty array)

1、Redis 字符串（String）

1、简介

• 是 Redis 中最简单的数据类型
• 一个 key 对应一个 value
• 是二进制安全的，可以包含任何数据，如：JPG图片、序列化的对象等等
• 一个Redis字符串value最多可以是512M

2、常用命令

命令	作用
set <key><value>	设定指定键的值
setnx <key><value>	当key不存在时，才设置key的值
mset <key1><value1><key2><value2>…	一次写入多个key和value
msetnx<key1><value1><key2><value2>	一次写入多个key和value（只有当设置的所有key中，在当前库中不存在，才能写入成功；）
get <key>	获取指定键的值
mget<key1><key2>…	一次获取多个key的值
append<key><value>	将值追加到指定key中原值的末尾
strlen <key>	获取key中value的长度
incr <key>	给key的value值加1（incr 只能对数字值操作）
decr <key>	给key的value值减1（decr 只能对数字值操作）
incrby <key> <步长>	给key的value值加指定步长，（incrby 只能对数字值操作）
decrby <key> <步长>	给key的value值减指定步长，（decrby 只能对数字值操作）
getrange<key><起始位置><结束位置>	获取值的范围
setrange<key><起始位置><value>	指定位置插入数据（会覆盖原数据）
setex<key><过期时间><value>	设置键值的同时，设置过期时间（单位：秒）
getset<key><value>	设置新值同时获取旧值

1、set <key><value> 和 get <key>命令

1、当前库中key的情况
127.0.0.1:6379> keys *
(empty array)

2、添加key
127.0.0.1:6379> set k1 v100
OK
127.0.0.1:6379> set k2 v200
OK

3、查看当前库中key的情况
127.0.0.1:6379> keys *
1) "k1"
2) "k2"

4、获取指定key的值
127.0.0.1:6379> get k1
"v100"

• 设置已存在key的值

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "k1"
2) "k2"

2、当前 k1的值
127.0.0.1:6379> get k1
"v100"

3、设置 k1的值
127.0.0.1:6379> set k1 v1100
OK

4、查看设置后，k1的值（原来的值v100被后来设置的v1100给覆盖了）
127.0.0.1:6379> get k1
"v1100"

2、 append<key><value>

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "k1"
2) "k2"

2、当前 k1的值
127.0.0.1:6379> get k1
"v1100"

3、将hell追加的 k1中原值v1100的末尾，成功后打印新value的长度10
127.0.0.1:6379> append k1 hello
(integer) 10

4、查看追加后的结果
127.0.0.1:6379> get k1
"v1100hello"

3、strlen <key> 获取key中value的长度

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "k1"
2) "k2"

2、当前 k1的值
127.0.0.1:6379> get k1
"v1100hello"

3、获取k1中value值的长度
127.0.0.1:6379> strlen k1
(integer) 10

4、setnx <key><value> 当key不存在时，才设置key的值

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "k1"
2) "k2"

2、当前 k1的值
127.0.0.1:6379> get k1
"v1100hello"

3、设置一个已经存在key的值（设置失败）
127.0.0.1:6379> setnx k1 123
(integer) 0

4、设置一个不存在key的值（设置成功）
127.0.0.1:6379> setnx k3 v300
(integer) 1
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"
127.0.0.1:6379> get k3
"v300"

5、incr <key> 和 decr <key>命令

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"

2、新建一个k4，设置一个数值类型的值
127.0.0.1:6379> set k4 100
OK
127.0.0.1:6379> get k4
"100"

3、通过 incr k4 设置k4的值加一（incr 只能对数字值操作）
127.0.0.1:6379> incr k4
(integer) 101
127.0.0.1:6379> get k4
"101"

4、通过 decr k4 设置k4的值减一（decr 只能对数字值操作）
127.0.0.1:6379> decr k4
(integer) 100
127.0.0.1:6379> get k4
"100"

6、incrby <key> <步长> 和 decrby <key> <步长>

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "k1"
2) "k4"
3) "k3"
4) "k2"

2、当前 k4值
127.0.0.1:6379> get k4
"100"

3、通过 incrby k4 100 给k4的值加100
127.0.0.1:6379> incrby k4 100
(integer) 200
127.0.0.1:6379> get k4
"200"

4、通过 decrby k4 100 给k4的值减150
127.0.0.1:6379> decrby k4 150
(integer) 50
127.0.0.1:6379> get k4
"50"

原子性

• Redis中的操作是 原子性操作，一旦开始不会其他线程调度机制打断（原子性）
• 在单线程中，能够在单条指令中完成的操作都可以认为是“原子操作”，中断只能发生于指令之间
• 在多线程中，不能被其他进程（线程）打断的操作也可以认为是“原子操作”
• Redis单命令的原子性，得益于Redis的单线程

7、mset <key1><value1><key2><value2>… 、msetnx<key1><value1><key2><value2> 和 mget<key1><key2>…

1、当前库中key的情况
127.0.0.1:6379> keys *
(empty array)

2、使用 mset一次写入多个key和value
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3
OK
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"

3、使用 msetnx 一次写入多个key（其中k3已经存在了）和value（写入失败）
-- 只有当设置的所有key中，在当前库中不存在，才能写入成功；
-- 只要在设置的所有key中，在当前库中已经存在，其余不重复的key也写入失败；
127.0.0.1:6379> msetnx k11 v11 k22 v22 k3 v3
(integer) 0

4、设置的所有key中，在当前库中不存在
127.0.0.1:6379> msetnx k11 v11 k22 v22 k33 v33
(integer) 1
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"
4) "k11"
5) "k22"
6) "k33"

5、使用 mget 一次取多个key的值
127.0.0.1:6379> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v3"

8、getrange<key><起始位置><结束位置> 获取值的范围

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"
4) "k11"
5) "k22"
6) "k33"

2、写入一个测试的值
127.0.0.1:6379> set name helloworld
OK

3、使用 getrange 获取 key是name 下标从 0-4五个下标的value值
127.0.0.1:6379> getrange name 0 4
"hello"

9、setrange<key><起始位置><value> 指定位置插入数据（会覆盖原数据）

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379> get name
"helloworld"

2、在 hello的后面插入 123，使用setrange（插入的数据会覆盖原来的数据）
127.0.0.1:6379> setrange name 5 123
(integer) 10
127.0.0.1:6379> get name
"hello123ld"

10 、setex<key><过期时间><value> 设置键值的同时，设置过期时间（单位：秒）

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "name"

2、设置一个 color的key,过期时间是：10秒，value值是：skyblue
127.0.0.1:6379> setex color 10 skyblue
OK
127.0.0.1:6379> ttl color
(integer) 8
127.0.0.1:6379> ttl color
(integer) 6
127.0.0.1:6379> ttl color
(integer) 5
127.0.0.1:6379> ttl color
(integer) 5
127.0.0.1:6379> ttl color
(integer) 3
127.0.0.1:6379> ttl color
(integer) 3
127.0.0.1:6379> ttl color
(integer) 1
127.0.0.1:6379> ttl color
(integer) 0
127.0.0.1:6379> ttl color
(integer) -2

3、当前库中key的情况
127.0.0.1:6379> keys *
1) "name"

11、getset<key><value> 设置新值同时获取旧值

1、当前库中key的情况
127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379> get name
"zhangsan"

2、设置 name的值为：lisi，打印name的旧值：zhangsan
127.0.0.1:6379> getset name lisi
"zhangsan"

3、获取name的值
127.0.0.1:6379> get name
"lisi"

3、数据结构

• 简单动态字符串（缩写SDS）
• 是可以修改的字符串
• 内部结构实现上类似于Java中的ArrayList
• 采用预分配冗余空间的方式来减少内存的频繁分配

• 内部为当前字符串实际分配的空间 capacity
• 一般要高于实际字符串长度 len
• 当字符串长度<1M时，扩容都是加倍现有的空间
• 当字符串长度>1M时，扩容时一次只会多扩1M的空间
• 字符串长度最大为512M

2、Redis 列表（List）

1、简介

• 相当于 Java 语言中的 LinkedList 结构，是一个链表而非数组
• Redis 列表的底层存储结构，是一个被称为快速链表（quicklist）的结构
• 当列表中存储的元素较少时，Redis 会使用一块连续的内存来存储这些元素，这个连续的结构被称为 ziplist 压缩列表
• 压缩列表是 Redis 为节省内存而开发的，它是由一系列特殊编码的连续内存块组成的顺序型数据结构，一个压缩列表可以包含任意多个节点，每个节点都可以保存一个字符数组或者整数值。
• 当数据量较大时，Redis 列表就会是用 quicklist 快速链表存储元素
• 采用了链表和压缩列表相结合的方式，也就是 quicklist + ziplist
• 将多个 ziplist 使用双向指针串联起来，这样既能满足快速插入、删除的特性，又节省了一部分存储空间

2、基础命令

命令	作用
lppush <key><value1><value2>…	从左写值
rpush<key><value1><value2>…	从右写值
lrange <key><起始位置><结束位置>	查看key中的元素，key 0 -1 表示查看当前key中所有元素
lpop	左取值
rpop	右取值
rpoplpush<key><key>	从第一个key的右边取一个值，插入到第二个key的左边
lindex<key><index>	按索引下标获取元素
llen<key>	获取列表长度
linsert <key> before<value><newvalue>	在key中的value之前插入一个新值newvalue
linsert <key> after<value><newvalue>	在key中的value之后插入一个新值newvalue
lrem<key><n><value>	从key中左边删除n个value（从左到右）
lset<key><index><value>	将key中下标为index的值替换为 value

1、lppush <key><value1><value2>… 、rpush<key><value1><value2>… 和 lrange <key><起始位置><结束位置>

1、当前数据库中的key情况
127.0.0.1:6379> keys *
(empty array)

2、使用 lpush 从左写值
127.0.0.1:6379> lpush k1 v1 v2 v3
(integer) 3

3、取值 0 -1 表示所有范围的值
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "v2"
3) "v1"

• 左写值
  

1、使用 rpush 从右写值
127.0.0.1:6379> rpush k2 v1 v2 v3
(integer) 3

2、取值
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v2"
3) "v3"

• 右写值
  

2、lpop<key> 左取值 和 rpop<key>右取值

1、当前数据库中的key情况
127.0.0.1:6379> keys *
1) "k2"
2) "k1"
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "v2"
3) "v1"

2、使用 lpop 从左取值
127.0.0.1:6379> lpop k1
"v3"
127.0.0.1:6379> lpop k1
"v2"
127.0.0.1:6379> keys * 
1) "k2"
2) "k1"

3、当 k1中的最后一个值被取出时，k2 就不存在了（值在键在，值无键无）
127.0.0.1:6379> lpop k1
"v1"
127.0.0.1:6379> keys * 
1) "k2"

1、当前数据库中的key情况
127.0.0.1:6379> keys * 
1) "k2"
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v2"
3) "v3"

2、右取值
127.0.0.1:6379> rpop k2 
"v3"

3、左取值
127.0.0.1:6379> lpop k2
"v1"

4、查看结果
127.0.0.1:6379> lrange k2 0 -1
1) "v2"

3、rpoplpush<右取值的key><放入key的左边>

1、左写值 k1
127.0.0.1:6379> lpush k1 v1 v2 v3
(integer) 3
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "v2"
3) "v1"

2、右写值 k2
127.0.0.1:6379> rpush k2 v11 v22 v33
(integer) 3
127.0.0.1:6379> lrange k2 0 -1
1) "v11"
2) "v22"
3) "v33"

3、使用 rpoplpush 从 k1的右边取一个值，放到k2的左边
127.0.0.1:6379> rpoplpush k1 k2
"v1"

4、查看结果
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "v2"
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v11"
3) "v22"
4) "v33"

• rpoplpush 右取值
  

4、lindex<key><index>按索引下标获取元素

1、当前 k2中的值
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v11"
3) "v22"
4) "v33"

2、按索引下标获取 k2的元素
127.0.0.1:6379> lindex k2 0
"v1"
127.0.0.1:6379> lindex k2 2
"v22"
127.0.0.1:6379> lindex k2 4 （超出索引）
(nil)

5、llen<key> 获取列表长度

1、当前 k2中的值
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v11"
3) "v22"
4) "v33"

2、获取 k2列表的长度
127.0.0.1:6379> llen k2
(integer) 4

6、linsert <key> before<value><newvalue> 在…之前插入一个新值

• before 在 … 之前

1、当前 k2中的元素
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v11"
3) "v22"
4) "v33"

2、在 k2中的 v11 前新增一个 hello的值
127.0.0.1:6379> linsert k2 before "v11" "hello"
(integer) 5
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "hello"
3) "v11"
4) "v22"
5) "v33"

3、在 k2中的 v22 前新增一个 hello的值
127.0.0.1:6379> linsert k2 before "v22" "hello"
(integer) 6
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "hello"
3) "v11"
4) "hello"
5) "v22"
6) "v33"

4、在 k2中的 v33 前新增一个 hello的值
127.0.0.1:6379> linsert k2 before "v33" "hello"
(integer) 7
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "hello"
3) "v11"
4) "hello"
5) "v22"
6) "hello"
7) "v33"

• after 在… 之后

1、当前 k1中的元素
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "v2"

2、在 k2中的 v3 后面新增一个 hello的值
127.0.0.1:6379> linsert k1 after "v3" "hello"
(integer) 3
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "hello"
3) "v2"

7、lrem<key><n><value> 从左边删除n个value（从左到右）

1、当前 k2中的元素
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "hello"
3) "v11"
4) "hello"
5) "v22"
6) "hello"
7) "v33"

2、在 k2中 从左往右删除2个 hello的值
127.0.0.1:6379> lrem k2 2 "hello"
(integer) 2

3、查看结果
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v11"
3) "v22"
4) "hello"
5) "v33"

8、lset<key><index><value> 将key中下标为index的值替换为 value

1、当前 k2中的元素
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v11"
3) "v22"
4) "hello"
5) "v33"


2、在 k2中将下标是0的“v1” 替换成 “helloworld”
127.0.0.1:6379> lset k2 0 helloworld
OK
127.0.0.1:6379> lrange k2 0 -1
1) "helloworld"
2) "v11"
3) "v22"
4) "hello"
5) "v33"

3、数据结构

• Redis 列表的底层存储结构，是一个被称为快速链表（quicklist）的结构
• 当列表中存储的元素较少时，Redis 会使用一块连续的内存来存储这些元素，这个连续的结构被称为 ziplist 压缩列表
• 压缩列表是 Redis 为节省内存而开发的，它是由一系列特殊编码的连续内存块组成的顺序型数据结构，一个压缩列表可以包含任意多个节点，每个节点都可以保存一个字符数组或者整数值。
• 当数据量较大时，Redis 列表就会是用 quicklist 快速链表存储元素
• 采用了链表和压缩列表相结合的方式，也就是 quicklist + ziplist
• 将多个 ziplist 使用双向指针串联起来，这样既能满足快速插入、删除的特性，又节省了一部分存储空间
  

3、Redis 集合（Set）

1、简介

• 类似于list列表的功能
• 可以自动去重（不存在重复的数据）
• 是String类型的无序集合，底层是一个value为null的哈希表

2、常用命令

命令	作用
sadd<key><value1><value2>…	添加一个或多个值
smembers<key>	取值
sismember<key><value>	判断key中是否存在该value，有返回1，没有返回0
scardy<key>	返回该集合的元素个数
spop<key>	随机从该集合中吐出一个值
srandmember<key><n>	随机从该集合中取出 n个值，但不会从集合中删除
smove<source><destination>value	把集合中一个值从一个集合移动到另一个集合
sinter<key1><key2>	返回两个集合的交集元素
sunion<key1><key2>	返回两个集合的并集元素
sdiff<key1><key2>	返回两个集合的差集元素（key1中存在，key2中不存在的元素）

1、sadd<key><value1><value2>… 添加一个或多个值 和 smembers<key>取值

1、一次新增多个值，其中 v2添加了两次
127.0.0.1:6379> sadd k1 v1 v2 v2 v3
(integer) 3

2、取值（使用 sadd 新增的值时，相同的值只取一个）
127.0.0.1:6379> smembers k1
1) "v2"
2) "v1"
3) "v3"

2、sismember<key><value> 判断key中是否存在该value，有返回1，没有返回0

1、当前 k1中的元素
127.0.0.1:6379> smembers k1
1) "v2"
2) "v1"
3) "v3"

2、判断 k1中是否存在 v2（存在返回 1）
127.0.0.1:6379> sismember k1 v2
(integer) 1

3、判断 k1中是否存在 v4（存在返回 0）
127.0.0.1:6379> sismember k1 v4
(integer) 0

3、scardy<key>返回该集合的元素个数

1、当前 k1中的元素
127.0.0.1:6379> smembers k1
1) "v2"
2) "v1"
3) "v3"

2、返回 k1中的元素个数
127.0.0.1:6379> scard k1
(integer) 3

4、spop<key> 随机从该集合中吐出一个值

1、当前 k1中的元素
127.0.0.1:6379> smembers k1
1) "v2"
2) "v1"
3) "v3"

2、随机从该集合中吐出一个值
127.0.0.1:6379> spop k1
"v1"
127.0.0.1:6379> spop k1
"v3"

3、再次查看 k1中的元素
127.0.0.1:6379> smembers k1
1) "v2"

5、srandmember<key><n> 随机从该集合中取出 n个值，但不会从集合中删除

1、当前 k1的元素
127.0.0.1:6379> smembers k1
1) "v4"
2) "v2"
3) "v1"
4) "v3"
5) "v5"

2、随机从 k1中取出2个元素
127.0.0.1:6379> srandmember k1 2
1) "v3"
2) "v1"
127.0.0.1:6379> srandmember k1 2
1) "v4"
2) "v1"

3、再次查看 k1中的元素
127.0.0.1:6379> smembers k1
1) "v4"
2) "v2"
3) "v1"
4) "v3"
5) "v5"

6、smove<source><destination>value 把集合中一个值从一个集合移动到另一个集合

1、当前 k1 k2中元素的情况
127.0.0.1:6379> smembers k1
1) "v4"
2) "v2"
3) "v1"
4) "v3"
127.0.0.1:6379> smembers k2
1) "v5"
2) "v4"
3) "v6"

2、将 k1中的 "v3"移动到 k2中
127.0.0.1:6379> smove k1 k2 v3
(integer) 1
127.0.0.1:6379> smembers k2
1) "v5"
2) "v4"
3) "v6"
4) "v3"
127.0.0.1:6379> smembers k1
1) "v4"
2) "v2"
3) "v1"


3、将 k1中的 "v4"移动到 k2中（k2中已存在“v4”）
127.0.0.1:6379> smove k1 k2 v4
(integer) 1
127.0.0.1:6379> smembers k1
1) "v2"
2) "v1"
127.0.0.1:6379> smembers k2
1) "v5"
2) "v4"
3) "v6"
4) "v3"

7、sinter<key1><key2> 返回两个集合的交集元素

1、当前 k1 k2中元素的情况
127.0.0.1:6379> smembers k1
1) "v2"
2) "v1"
3) "v3"
127.0.0.1:6379> smembers k2
1) "v5"
2) "v4"
3) "v3"

2、返回两个集合的交集元素
127.0.0.1:6379> sinter k1 k2
1) "v3"

8、sunion<key1><key2> 返回两个集合的并集元素

1、当前 k1 k2中元素的情况
127.0.0.1:6379> smembers k1
1) "v2"
2) "v1"
3) "v3"
127.0.0.1:6379> smembers k2
1) "v5"
2) "v4"
3) "v3"

2、返回两个集合的并集元素
127.0.0.1:6379> sunion k1 k2
1) "v2"
2) "v1"
3) "v3"
4) "v5"
5) "v4"

9、sdiff<key1><key2> 返回两个集合的差集元素（key1中存在，key2中不存在的元素）

1、当前 k1 k2中元素的情况
127.0.0.1:6379> smembers k1
1) "v4"
2) "v2"
3) "v1"
4) "v3"
127.0.0.1:6379> smembers k2
1) "v5"
2) "v4"
3) "v6"

2、以 k1为准，返回k2中不存在的元素
127.0.0.1:6379> sdiff k1 k2
1) "v2"
2) "v1"

3、数据结构

• Set数据结构是dict字典，通过哈希表实现
• hash结构，所有的value都指向同一个内部值

4、Redis 哈希（Hash）

1、简介

• 是一个键值对集合
• 是一个String类型的 field 和 value 的映射表，适合用于存储对象
• 类似于Java中的Map<String,Object>

• Hash采取的是第三种
  

2、基本命令

命令	作用
hset <key><field><value>	给key集合中的field键赋值value
hget<key><field>	取值
hmset<key1><field1><value1><field1><value1>…	一次添加多个值
hkeys<key>	列出key中所有的field
hvals<key>	列出key中所有的value
hexists<key><field>	查看哈希表key中，field是否存在
hincrby<key><field><increment>	为key中field对应的值加上增量
hsetnx<key><field><value>	当key中field不存在时，将field对应的值设置为 value

1、hset <key><field><value> 给key集合中的field键赋值value 和 hget<key><field>取值

1、写值
127.0.0.1:6379> hset user:001 name zhangsan
(integer) 1
127.0.0.1:6379> hset user:001 age 10
(integer) 1

2、通过 key 和 field键取值
127.0.0.1:6379> hget user:001 name
"zhangsan"
127.0.0.1:6379> hget user:001 age
"10"

2、hmset<key1><field1><value1><field1><value1>…一次添加多个值

1、一次添加多个值
127.0.0.1:6379> hmset user:002 name lisi age 30 shenggao 173
OK

2、取值
127.0.0.1:6379> hget user:002 name
"lisi"
127.0.0.1:6379> hget user:002 age
"30"
127.0.0.1:6379> hget user:002 shenggao
"173"

3、hkeys<key> 列出key中所有的field 和 hvals<key> 列出key中所有的value

1、列出key是user:002中所有的field
127.0.0.1:6379> hkeys user:002
1) "name"
2) "age"
3) "shenggao"

2、列出key是user:002中所有的value
127.0.0.1:6379> hvals user:002
1) "lisi"
2) "30"
3) "173"

4、hexists<key><field>查看哈希表key中，field是否存在

1、当前 key= user:002中所有的field
127.0.0.1:6379> hkeys user:002
1) "name"
2) "age"
3) "shenggao"

2、查看key= user:002中的field=“name”是否存在（存在返回1）
127.0.0.1:6379> hexists user:002 name
(integer) 1

3、查看key= user:002中的field=“tel”是否存在（不存在返回0）
127.0.0.1:6379> hexists user:002 tel
(integer) 0

5、hincrby<key><field><increment>为key中field对应的值加上增量

1、key=user:002中的field和value情况
127.0.0.1:6379> hkeys user:002
1) "name"
2) "age"
3) "shenggao"
127.0.0.1:6379> hvals user:002
1) "lisi"
2) "30"
3) "173"

2、给 key=user:002中field="age"对应的30加20
127.0.0.1:6379> hincrby user:002 age 20
(integer) 50
127.0.0.1:6379> hvals user:002
1) "lisi"
2) "50"
3) "173"

3、给 key=user:002中field="age"对应的50减20
127.0.0.1:6379> hincrby user:002 age -20
(integer) 30
127.0.0.1:6379> hvals user:002
1) "lisi"
2) "30"
3) "173"

6、hsetnx<key><field><value> 当key中field不存在时，将field对应的值设置为 value

1、key=user:002中的field和value情况
127.0.0.1:6379> hkeys user:002
1) "name"
2) "age"
3) "shenggao"
127.0.0.1:6379> hvals user:002
1) "lisi"
2) "30"
3) "173"

2、设置key=user:002中field=“name”对应的值为 “zhangsan”（field=“name”已经存在，设置失败）
127.0.0.1:6379> hsetnx user:002 name zhangsan
(integer) 0

3、设置key=user:002中field=“tel”对应的值为 “123456789”（field=“tel”不存在，设置成功）
127.0.0.1:6379> hsetnx user:002 tel 123456789
(integer) 1

4、查看结果
127.0.0.1:6379> hkeys user:002
1) "name"
2) "age"
3) "shenggao"
4) "tel"
127.0.0.1:6379> hvals user:002
1) "lisi"
2) "30"
3) "173"
4) "123456789"

3、数据结构

• 对应的数据结构分别是：压缩列表（ziplist）和 哈希表（hashtable）
• field-value长度较短且个数较少时，使用 压缩列表
• field-value长度较长且个数较多时，使用 哈希表

5、Redis 有序集合（Zset）

1、简介

• 有序集合，是一个没有重复元素的字符串集合
• 有序集合中的每一个成员都关联了一个评分（score），用来按照从最低分到最高分的方式排序集合中的成员
• 集合中的成员是唯一的，但评分是可以重复的

2、基本命令

命令	作用
zadd<key><score1><value1><score2><value2>…	一次写入多个值
zrange <key>	查看值
zrangebyscore key minmax[withscores][limit offset count ]	返回key中，所有score介于min和max之间（包括等于）的成员，从小到大排列
zrevrangebyscore key maxmin [withscores][limit offset count]	返回key中，所有score介于max和min之间（包括等于）的成员，从大到小排列
zincrby<key><increment><value>	为元素的score加上增量
zrem<key><value>	删除该集合下，指定值的元素
zcount<key><min><max>	统计该集合，分数区间内的元素个数
zrank<key><value>	返回该value在集合中的排名，从0开始

1、zadd<key><score1><value1><score2><value2>… 一次写入多个值 和 zrange <key> 查看值

1、一次写入多个值
127.0.0.1:6379> zadd k1 100 java 200 c++ 300 phthon 400 c
(integer) 4

2、只查看值value
127.0.0.1:6379> zrange k1 0 -1
1) "java"
2) "c++"
3) "phthon"
4) "c"

3、查看值和评分 withscores（默认从小到大排序）
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "java"
2) "100"
3) "c++"
4) "200"
5) "phthon"
6) "300"
7) "c"
8) "400"

2、zrangebyscore key minmax[withscores][limit offset count ] 返回key中，所有score介于min和max之间（包括等于）的成员，从小到大排列

1、k1中的情况
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "java"
2) "100"
3) "c++"
4) "200"
5) "phthon"
6) "300"
7) "c"
8) "400"

2、查看 评分score在 200-300之间的成员
127.0.0.1:6379> zrangebyscore k1 200 300
1) "c++"
2) "phthon"

3、查询结果显示评分
127.0.0.1:6379> zrangebyscore k1 200 300 withscores
1) "c++"
2) "200"
3) "phthon"
4) "300"

3、zrevrangebyscore key maxmin [withscores][limit offset count]返回key中，所有score介于max和min之间（包括等于）的成员，从大到小排列

1、k1中的情况
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "java"
2) "100"
3) "c++"
4) "200"
5) "phthon"
6) "300"
7) "c"
8) "400"

2、查看 评分score在 400-200之间的成员
127.0.0.1:6379> zrevrangebyscore k1 400 200 
1) "c"
2) "phthon"
3) "c++"

3、查询结果显示评分
127.0.0.1:6379> zrevrangebyscore k1 400 200 withscores
1) "c"
2) "400"
3) "phthon"
4) "300"
5) "c++"
6) "200"

4、zincrby<key><increment><value> 为元素的score加上增量

1、k1中的情况
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "java"
2) "100"
3) "c++"
4) "200"
5) "phthon"
6) "300"
7) "c"
8) "400"

2、给 k1中的Java的score加上50的增量
127.0.0.1:6379> zincrby k1 50 java
"150"

3、查看结果
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "java"
2) "150"
3) "c++"
4) "200"
5) "phthon"
6) "300"
7) "c"
8) "400"

5、zrem<key><value> 删除该集合下，指定值的元素

1、k1中的情况
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "java"
2) "100"
3) "c++"
4) "200"
5) "phthon"
6) "300"
7) "c"
8) "400"

2、删除 
127.0.0.1:6379> zrem k1 java
(integer) 1

3、查看结果
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "c++"
2) "200"
3) "phthon"
4) "300"
5) "c"
6) "400"

6、zcount<key><min><max>统计该集合，分数区间内的元素个数

1、当前 k1中的情况
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "c++"
2) "200"
3) "phthon"
4) "300"
5) "c"
6) "400"

2、查看 k1中评分在 200-300之间的元素个数
127.0.0.1:6379> zcount k1 200 300
(integer) 2

7、zrank<key><value>返回该value在集合中的排名，从0开始

1、当前 k1中的情况
127.0.0.1:6379> zrange k1 0 -1 withscores
1) "c++"
2) "200"
3) "phthon"
4) "300"
5) "c"
6) "400"

2、查看value=“phthon”在k1中的排名（第1位）
127.0.0.1:6379> zrank k1 phthon
(integer) 1

3、数据结构

• 类似于Java中的Map<String,Double>
• 一方面可以给每个元素赋予一个权重score
• 另一方面又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表
• Zset底层使用了两个数据结构：

1. hash,作用是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到对应的score值。
2. 跳跃表，目的在于给元素value排序，根据score的范围获取元素列表。

【尚硅谷】Redis 6 入门到精通 超详细 教程