1. 键（key）

1. 命令

keys * 		查看key
exists key	判断是否存在
type key	key的类型
del key 	删除key
unlink key 	根据value选择非阻塞删除(异步删除)
expire key time[s]	设置key的过期时间
ttl key		查看还有多少秒过期，-1表示你永不过期，-2表示已过期（过期则直接丢弃）
select <dbid>	切换数据库
dbsize  	查看当前数据库有多少个key
flushdb		清空当前库
flushall	清空所有库

2. 测试

#添加键值
127.0.0.1:6379> set k1 lucy
OK
127.0.0.1:6379> set k2 jack
OK
127.0.0.1:6379> set k3 Tom
OK
#查看键值
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"

127.0.0.1:6379> exists k1
(integer) 1
127.0.0.1:6379> exists k4
(integer) 0

127.0.0.1:6379> type k2
string

127.0.0.1:6379> del k3
(integer) 1
127.0.0.1:6379> keys *
1) "k1"
2) "k2"

#设置时效性
127.0.0.1:6379> expire k1 3
(integer) 1
127.0.0.1:6379> ttl k1
(integer) -2
127.0.0.1:6379> keys *
1) "k2"
127.0.0.1:6379> dbsize
(integer) 1
127.0.0.1:6379> select 2
OK
127.0.0.1:6379[2]> dbsize
(integer) 0

2. String

1. 二进制安全，可以存放任何数据，value 最大为512M

set <key> <value>
get <key>
append <key> <value>		在给定的<value>后面追加
strlen <key>
setnx <key> <value> 	只有不存在的时候才能设置成功
incr <key>		将存储的数字值加1，只能对数字值操作；为空，新增值为1
decr <key>		将存储的数字值减1
incrby/decrby <key> <step>	将存储的数字值加/减step
mset <key1> <value1> <key1> <value2> ..	 同时设置多个值(一个失败都失败，原子操作)
mget <key1>  <key2> ..	 同时获取多个值(一个失败都失败，原子操作)
msetnx <key1> <value1> <key2> <value2> ..	 同时设置多个值(一个失败都失败，原子操作)
getrange <key> <起始位置><结束位置>	获取值的一段长度
setrange <key> <起始位置><value>	从起始位置开始用value覆盖之后的值
setex <key> <seond>  <value>	设置过期时间
getset <key> <value>	设置新值，并返回旧值

2. 所有操作都是原子操作:不会被线程调度机制打断
   java的自加加操作不是原子操作，i++:可以分为i+1,和i = i+1，多个线程的话，两步可能被打断，导致加一和赋值不是同一个值

3. 数据结构为简单动态字符串，可以修改，类似java的ArrayList,采用预分配冗余空间的方式，减少频繁内存空间分配

   1. 字符串长度小于1M时，扩容都是加倍现有的空间;
   2. 大于1M时，每次扩容1M;
   3. 最大不能超过512M

127.0.0.1:6379[2]> mset k6 120 k9 129 k0 qw
OK
127.0.0.1:6379[2]> keys *
1) "k9"
2) "k0"
3) "k6"
127.0.0.1:6379[2]> mget k6 k9 k0
1) "120"
2) "129"
3) "qw"

3. List

单键多值

1. 可以在头部和尾部添加元素
2. 常用命令

lpush/rpush <key> <value1> <value2> ...		从左边/右边插入一个或多个值（初始也是这样）
lpop/rpop <key> 		从左边/右边弹出一个值，值在键在，值光键亡
rpoplpush <key1> <key2>		从<key1>列表右边吐出一个值，插到<key2>列表左边(没有lpoprpush )
lrange <key> <start> <stop>		按照索引下标获得元素（从左到右）0表示左边第一个，-1表示右边第一个）
lindex <key> <index> 	按照索引下标获得元素
llen <key>	获取列表长度

linsert <key> before/after <value> <newvalue>		在遇到的第一个等于value前/后面插入newvalue
lrem <key> <n> <value>  从左边删除n个value值（超过则删除全部相同值）

3. 具体的底层数据结构
   快速链表quickList
   • 列表元素较少，使用一块连续的内存空间，结构为zipList(压缩链表)，将所有元素紧挨着一起存储
   • 数据量比较大的时候，才会使用quickList（双向链表），将一个个ziplist连接起来
   • 双向链表，对两端的操作性能较高，通过索引下标操作中间的节点性能较差

127.0.0.1:6379> lpush k2 12 343 56
(integer) 3
127.0.0.1:6379> lrange k2 0 -1
1) "56"
2) "343"
3) "12"
127.0.0.1:6379> keys *
1) "k1"
2) "k2"
127.0.0.1:6379> lpush k2 56 56
(integer) 5
127.0.0.1:6379> lrange k2 0 -1
1) "56"
2) "56"
3) "56"
4) "343"
5) "12"
127.0.0.1:6379> linsert k2 before 56 2
(integer) 6
127.0.0.1:6379> lrange k2 0 -1
1) "2"
2) "56"
3) "56"
4) "56"
5) "343"
6) "12"

127.0.0.1:6379> lrem k2 5 56
(integer) 3
127.0.0.1:6379> lrange k2 0 -1
1) "2"
2) "343"
3) "12"

4. set

1. 特点
   • 自动去重
   • 提供了判断某元素是否存在的接口
   • 无序集合，底层是value为null的hash表
   • 添加，删除，查找，复杂度都是O(1)
2. 常用命令

sadd <key> <value1> <value2> ...		添加一个或多个值（初始也是这样）
smembers <key> 		获取所有值
sismember <key1> <value1>		<key1>中，是否存在value1
scard  <key>		<key1>中的元素个数
srem <key> <value1> <value2> ... 	删除<key1>中指定的元素，没有的元素则跳过
spop <key> 		随机吐出一个值，值光键亡
srandmember <key> <n>		随机获取n个值，不从集合中删除

#多集合之间的操作
smove <key1> <key2> <value>		将value从<key1>移动到 <key2>
sinter <key1> <key2>		返回两个集合的交集元素
sunion <key1> <key2>		返回两个集合的并集元素
sdiff <key1> <key2>			返回两个集合的差集元素（包含key1,不包含key2）

3. 底层结构
   底层使用hash结构

127.0.0.1:6379> sadd k1 12 23 12 45 24
(integer) 4
#是否存在
127.0.0.1:6379> sismember k1 3
(integer) 0
127.0.0.1:6379> sismember k1 12
(integer) 1
127.0.0.1:6379> sismember k3 1
(integer) 0
# 查看
127.0.0.1:6379> smembers k1
1) "12"
2) "24"
3) "45"
#  删除操作
127.0.0.1:6379> srem k1 3
(integer) 0
127.0.0.1:6379> scard k1
(integer) 3
127.0.0.1:6379> srem k1 3 12
(integer) 1
127.0.0.1:6379> scard k1
(integer) 2

5. Hash

1. 特点
   • 键值对的集合
   • 一个string类型的field和value的映射表，hash特别适合用于存储对象
2. 常见命令

hset <key> <field> <value>		给<key>集合中的<field>键赋值<value>
hget <key> <field>		获取<key>集合中的<field>键的值<value>
hmset <key> <field1> <value1> <field2> <value2> ... 		批量给<key>集合中的<field>键赋值<value>
hexists <key> <field> 查看元素是否存在
hkeys <key>		列出当前key的所有 field
hvals <key>		列出当前key的所有value
hincrby <key> <field> <increment>		为field的值添加增量<increment>,仅限于数值类型
hsetnx <key> <field> <value>		给<key>集合中的<field>键赋值<value>,仅当field不存在的时候

3. 数据结构
   • 数据量比较短且少的时候，使用zipList
   • 数据量比较多的时候，使用hashtable

127.0.0.1:6379> hmset k1 id 1 name jack age 24
OK

127.0.0.1:6379> hkeys k1
1) "id"
2) "name"
3) "age"

127.0.0.1:6379> hincrby k1 age -2
(integer) 22

127.0.0.1:6379> hvals k1
1) "1"
2) "jack"
3) "22"

6. Zset（sorted set）

1. 特点
   • 没有重复元素的字符串集合
   • 每个成员都关联一个评分(score)，并以此进行升序排列，评分值可以重复
2. 常用命令

zadd <key> <score1> <value1>  <score2> <value2>  ...		将一个或多个member元素加入的到有序key当中
zrange <key> <start> <stop> [withscores]		返回有序集key中，下标在start-stop之间的元素，是否返回分数
zrangebyscore key min max [withscores] [limit offset count]		返回指定分数区间的元素
zincrby <key> <incrment> <value>		为元素<value>添加增量
zrem <key> <value>
zcount <key> <min> <max>		统计在指定分数区间内的元素
zrank <key> <value>		返回该值在集合中的排名，从0开始

3. 底层结构
   1. hash结构：可以像Map<String,Double> 赋予权重，并像TreeSet内部按照权重排序
   2. 跳跃表：通过给元素value排序，根据权重获取元素的列表
      
      逐层细化查找范围

127.0.0.1:6379> zadd k1 23 jack 22 rose 42 jerry
(integer) 3

127.0.0.1:6379> zrange k1 0 -1
1) "rose"
2) "jack"
3) "jerry"

127.0.0.1:6379> zrange k1 0 -1 withscores
1) "rose"
2) "22"
3) "jack"
4) "23"
5) "jerry"
6) "42"


127.0.0.1:6379> zrange k1 (22 40 byscore
1) "jack"
127.0.0.1:6379> zrange k1 40 (22 byscore rev
1) "jack"

127.0.0.1:6379> zincrby k1 2 40
"2"
127.0.0.1:6379> zrange k1 0 -1
1) "40"
2) "rose"
3) "jack"
4) "jerry"


127.0.0.1:6379> zcount k1 -inf +inf
(integer) 4

127.0.0.1:6379> zrank k1 jack
(integer) 2