Redis有5中数据基础数据结构，分别是String（字符串）、list(列表)、set(集合)、hash(哈希)和zset(有序集合)。熟练账务这5种基本数据结构的使用是Redis知识最基础的重要部分。
String（字符串）
字符串string是Redis最简单的数据结构。Redis所有的数据结构都是以唯一的key字符串作为名称，然后通过这个唯一key值获取value数据。不同类型的数据结构和差异就在于value的结构不一样。
字符串结构使用非常广泛，一个常见的用途就是缓存用户信息。我们将用户信息结构体使用json序列化成字符串，然后将序列后的字符串塞进Redis做缓存。同样，取出用户信息会经历一次反序列化的过程。
Redis的字符串是动态字符串，是可以修改的字符串，内部结构实现类似于java的ArrayList，蝉蛹预分配冗余空间方式来减少内存的频繁分配，如图所示，内部为当前字符串实际分配的空间capacity一般要高于实际字符串长度len。当字符串长度小于1M时，扩容都是加倍现有空间，如果超过1M，扩容时一次只会扩容1M空间。需要注意的是字符串最大长度为512M。
键值对
> set name hello
OK
> get name
"hello"
> exists name
(integer) 1
> del name
(integer) 1
> get name
(nil)
批量键值对
> set name1 hello
OK
> set name2 world
OK
> mget name1 name2 name3 # 返回一个列表
1) "hello"
2) "world"
3) (nil)
> mset name1 boy name2 girl name3 unknown
> mget name1 name2 name3
1) "boy"
2) "girl"
3) "unknown"
过期和 set 命令扩展
可以对key设置过期时间，到点自动删除，这个功能常用来控制缓存的失效时间。
> set name codehole
> get name
"codehole"
> expire name 5 # 5s 后过期
... # wait for 5s
> get name
(nil)
> setex name 5 codehole # 5s 后过期，等价于 set+expire
> get name
"codehole"
... # wait for 5s
> get name
(nil)
> setnx name codehole # 如果 name 不存在就执行 set 创建
(integer) 1
> get name
"codehole"
> setnx name holycoder
(integer) 0 # 因为 name 已经存在，所以 set 创建不成功
> get name
"codehole" # 没有改变
计数
如果value值是一个整数，还可以对他进行自增操作。自增是有范围的，他的范围是signed long的最大最小值，超过了这个值，Redis会报错。
> set age 30
OK
> incr age
(integer) 31
> incrby age 5
(integer) 36
> incrby age -5
(integer) 31
> set codehole 9223372036854775807 # Long.Max
OK
> incr codehole
(error) ERR increment or decrement would overflow
字符串由多个字节组成，每个字节又是由8个bit组成，如此便可以将一个字符串堪称很多bit组合，这便是bitmap[位图]数据结构。
list(列表)
Redis的列表相当于java语言里面的LinkedList，注意他是链表而不是数组。这意味着list的插入和删除速度非常快，时间复杂度为0(1)，但是索引定位很慢，时间复杂度为0(n)。
当列表弹出最后一个元素之后，该数据结构自动被删除，内存被回收。
Redis的列表结构常用来做异步队列使用。将需要延后处理的任务结构体序列化成字符串塞进redis的列表，另一个线程从这个列表中轮训数据进行处理。
右边进左边出：队列
> rpush books python java golang
(integer) 3
> llen books
(integer) 3
> lpop books
"python"
> lpop books
"java"
> lpop books
"golang"
> lpop books
(nil)
右边进右边出：栈
> rpush books python java golang
(integer) 3
> rpop books
"golang"
> rpop books
"java"
> rpop books
"python"
> rpop books
(nil)
慢操作
index相当于java链表get(index)方法，它需要对链表进行遍历，性能随着index增大而变差。
ltrim和字面上的含义不太一样，ltrim跟两个参数start_index和end_index定义了一个区间，在这个区间内的值，ltrim要保留，区间之外统统砍掉。我们可以通过ltrim来实现一个订场列表，这一点非常有用。
index可以是负数，index=-1表示倒数第一个元素，同样index=-2表示倒数第二个元素。
> rpush books python java golang
(integer) 3
> lindex books 1 # O(n) 慎用
"java"
> lrange books 0 -1 # 获取所有元素，O(n) 慎用
1) "python"
2) "java"
3) "golang"
> ltrim books 1 -1 # O(n) 慎用
OK
> lrange books 0 -1
1) "java"
2) "golang"
> ltrim books 1 0 # 这其实是清空了整个列表，因为区间范围长度为负
OK
> llen books
(integer) 0
快速列表
如果在深入一点你会发现redis底层存储的还不是一个简单的linkedlist，而是称之为快速链表quicklist的一个结构。
首先在列表元素较少的情况下回使用一块连续的内存存储，这个结构是ziplist，也即是压缩列表。它将所有的元素紧挨着一起存储，分配的是一块连续的内存。当数据量比较多的时候才改成quicklist。因为普通的链表需要的附加指针空间太大，会比较浪费空间，而且会加重内存的碎片化。比如这个列表里存的只是int类型的数据，结构上海需要两个额外的指针pre和next。所以redis将链表和ziplist结合起来组成了quicklist。也就是将多个自ziplist使用双向指针串起来使用。。这样既满足了快速插入删除性能，又不会出现太大的空间冗余。
hash（字典）
Redis的字典相当于java里的hashmap，它是无需字典。内部实现结构也同java的HashMap也是一致的，同样的数组+链表二维结构。第一维hash的数组位置碰撞时，就会将碰撞的元素使用链表串接起来。
不同的是，Redis的字典的值只能是字符串，另外它们的rehash的方式不一样，因为java的HashMap在字典很大时，rehash是个耗时的操作，需要一次性全部rehash。redis为了高性能，不能堵塞服务，所以采用了渐进式rehash策略。
渐进式rehash会在rehash的同时，保留新旧两个hash结构，查询时会同时查询两个hash结构，然后在后续的定时任务中以及hash操作指令中，循序渐进的讲旧hash的内容一点点的迁移到新hash结构中。当搬迁完成了，就会使用新的hash取而代之。
当hash移除了最后一个元素后，该数据结构自动被删除，内存被回收。
hash结构也可以用来存储用户信息，不同于字符串一次性需要全部序列化整个对象，hash可以对用户结构中的每个字段单独存储。这样当我们需要获取用户信息时可以进行部分获取。而以整个字符串的形式去保存用户信息的话就只能一次性全部读取，这样就会比较浪费网络流量。
hash也有缺点，hash结构的存储消耗要高于单个字符串，到底是使用hash还是使用字符串，需要根据实际情况再三权衡。
> hset books java "think in java" # 命令行的字符串如果包含空格，要用引号括起来
(integer) 1
> hset books golang "concurrency in go"
(integer) 1
> hset books python "python cookbook"
(integer) 1
> hgetall books # entries()，key 和 value 间隔出现
1) "java"
2) "think in java"
3) "golang"
4) "concurrency in go"
5) "python"
6) "python cookbook"
> hlen books
(integer) 3
> hget books java
"think in java"
> hset books golang "learning go programming" # 因为是更新操作，所以返回 0
(integer) 0
> hget books golang
"learning go programming"
> hmset books java "effective java" python "learning python" golang "modern golang programming" # 批量 set
OK
set(集合)
Redis的集合相当于java语言里面的HashSet，它内部的键值对是无序的唯一的。他的内部实现相当于一个特殊的字典，字典中所有的value都是一个值NULL。
当集合中最后一个元素移除后，数据结构自动删除，内存被回收。
set结构可以用来存储活动中奖的用户ID，因为有去重功能，可以保证同一个用户不会中奖两次。
> sadd books python
(integer) 1
> sadd books python # 重复
(integer) 0
> sadd books java golang
(integer) 2
> smembers books # 注意顺序，和插入的并不一致，因为 set 是无序的
1) "java"
2) "python"
3) "golang"
> sismember books java # 查询某个 value 是否存在，相当于 contains(o)
(integer) 1
> sismember books rust
(integer) 0
> scard books # 获取长度相当于 count()
(integer) 3
> spop books # 弹出一个
"java"
zset(有序集合)
zset可能是redis提供的最具特色的数据结构，他也是在面试中面试官最喜欢问的数据结构。它类似于java的SortedSet和HashMap的结合体，一方面他是一个set，保证了内部value的唯一性，另一方面它可以给每个value赋予一个score。代表的排序权重。他的内部实现是一种叫做【跳跃列表】的结构。
zset中最后一个value被移除后，数据结构自动删除，内存被回收。
zset可以用来存粉丝列表，value值是粉丝的用户id，score是关注时间。我们可对粉丝列表按关注时间进行排序。
zset还可以用来存储学生的成绩，value值是学生的id，score是考试成绩。
> zadd books 9.0 "think in java"
(integer) 1
> zadd books 8.9 "java concurrency"
(integer) 1
> zadd books 8.6 "java cookbook"
(integer) 1
> zrange books 0 -1 # 按 score 排序列出，参数区间为排名范围
1) "java cookbook"
2) "java concurrency"
3) "think in java"
> zrevrange books 0 -1 # 按 score 逆序列出，参数区间为排名范围
1) "think in java"
2) "java concurrency"
3) "java cookbook"
> zcard books # 相当于 count()
(integer) 3
> zscore books "java concurrency" # 获取指定 value 的 score
"8.9000000000000004" # 内部 score 使用 double 类型进行存储，所以存在小数点精度问题
> zrank books "java concurrency" # 排名
(integer) 1
> zrangebyscore books 0 8.91 # 根据分值区间遍历 zset
1) "java cookbook"
2) "java concurrency"
> zrangebyscore books -inf 8.91 withscores # 根据分值区间 (-∞, 8.91] 遍历 zset，同时返回分值。inf 代表 infinite，无穷大的意思。
1) "java cookbook"
2) "8.5999999999999996"
3) "java concurrency"
4) "8.9000000000000004"
> zrem books "java concurrency" # 删除 value
(integer) 1
> zrange books 0 -1
1) "java cookbook"
2) "think in java"
跳跃列表
zset内部的排序功能是通过跳跃列表数据结构来实现的，它的数据结构非常特殊，也比较复杂。
因为zset要支持随机的插入和删除，所以它不好使用数组来表示。我们先看一个普通的链表结构。
我们需要这个链表按照score值进行排序。这意味着当有新元素插入时，要定位到特定位置的插入点，这样才可以继续保证链表是有序。通常我们会通过二分查找来找到插入点，但是二分查找的对象必须是数组，只有数组才可以快速定位，链表做不到，那该怎么办呢？
想想一个创业公司，刚开始只有几个人，团队成员之间人人平等，都是联合创始人。随着公司的成长，人数渐渐变多，团队沟通成本随之增加。这时候就会引入组长制，对团队进行划分。每个团队会有一个组长。开会的时候分团队进行，多个组长之间还会有自己的会议安排。公司规模进一步扩展，需要再增加一个层级 —— 部门，每个部门会从组长列表中推选出一个代表来作为部长。部长们之间还会有自己的高层会议安排。
跳跃列表就是类似于这种层级制，最下面一层所有的元素都会串起来。然后每隔几个元素挑选出一个代表来，再将这几个代表使用另外一级指针串起来。然后在这些代表里再挑出二级代表，再串起来。最终就形成了金字塔结构。
跳跃列表之所以跳跃，是因为内部元素可能身兼数职。
定位插入点时，现在顶层进行定位，然后在潜到下一级定位，一直潜到最底层找到合适的位置，然后将新元素插进去。
容器型数据结构的通用规则
list/set/hash/zset这4种数据结构是容器型数据结构，它们共享下面两条通用规则：
1.create if not exists 如果容器不存在，那就创建一个，再进行操作。比如 rpush 操作刚开始是没有列表的，Redis 就会自动创建一个，然后再 rpush 进去新元素。
2.drop if no elements 如果容器里元素没有了，那么立即删除元素，释放内存。这意味着 lpop 操作到最后一个元素，列表就消失了。