阿桃_28e7
阿桃_28e7

redis第三章：数据结构

redis数据结构

键管理

# 查看键数量：DBSIZE
127.0.0.1:6379> dbsize
(integer) 18

# 查询匹配的键(过时)：KEYS pattern (支持glob风格通配符格)(生产环境禁止使用)[已被SCAN命令取代]
127.0.0.1:6379> keys *
 1) "session:2018"
 2) "ls"
 3) "ss2"
 4) "\xac\xed\x00\x05t\x00\x02k2"
 5) "ls2"
 6) "k"
 7) "foo"
 8) "user:2:followers"
 9) "uid"
10) "num"
11) "myzset"
12) "user:1:following"
13) "mylsalpha"
14) "dsts"
15) "ss"
16) "k2"
17) "preredis中key和value的存储大小限制
18) "key"

# 查询匹配的键(流行)：SCAN cursor [MATCH pattern] [COUNT number] [TYPE type]
# 第一次scan返回结果为空，但第二次不为空，cursor为0表示已经扫描完所有键
127.0.0.1:6379> scan 0 match key count 10
1) "22"
2) (empty list or set)
127.0.0.1:6379> scan 22 match key count 10
1) "0"
2) 1) "key"

# 判断键是否存在: EXISTS key [key ...] 
# 存在返回1, 否则返回0, 多个键作为参数则返回，其中已经存在的键的数量
127.0.0.1:6379> exists foo myzset fakekey
(integer) 2
127.0.0.1:6379> exists foo
(integer) 1
127.0.0.1:6379> exists fakekey
(integer) 0127.0.0.1:6379> exists foo
(integer) 1
127.0.0.1:6379> exists fakekey
(integer) 0

# 删除键(小key): DEL key [key ...]
# DEL命令的参数不支持通配符,可以结合linux的管道和xargs命令实现删除所有符合规则的键
127.0.0.1:6379> del foo
(integer) 1
127.0.0.1:6379> del fakekey
(integer) 0

# 删除键(大key): UNLINK key [key ...]
127.0.0.1:6379> unlink bigkey
(integer) 1
127.0.0.1:6379> unlink fakekey
(integer) 0

# 查询键值的数据类型: TYPE key
127.0.0.1:6379> type fakekey
none
127.0.0.1:6379> type mystring
string
### 特别注意： 单个数字在redis中也是用string类型存储的
127.0.0.1:6379> type numStr
string
127.0.0.1:6379> type ls
list
127.0.0.1:6379> type myzset
zset
127.0.0.1:6379> type numSet
set
127.0.0.1:6379> type userMap
hash
127.0.0.1:6379> type hll # HyperLogLog
string
127.0.0.1:6379>  type nearRestaurants # GEO
zset

# 查询值对象的内部编码方式：OBJECT ENCODING [arguments [arguments ...]]
127.0.0.1:6379> object encoding fakekey
(nil)
127.0.0.1:6379> object encoding mystring
"embstr"
127.0.0.1:6379> object encoding ls
"quicklist"
127.0.0.1:6379> object encoding myzset
"ziplist"
127.0.0.1:6379> object encoding numSet
"intset"
127.0.0.1:6379> object encoding userMap
"ziplist"
127.0.0.1:6379> object encoding hll # HyperLogLog
"raw"
127.0.0.1:6379> object encoding nearRestaurants # GEO
"ziplist"

glob风格通配符规则:

符号 意义
? 匹配一个字符
* 匹配任意个(包括0个)字符
[] 匹配括号内任一字符,可以使用"-"表示一个范围,如:a[b-d]可以匹配ab,ac,ad
\x 匹配字符x,用于转义符号.如要匹配"?",就需要使用?

DEL命令技巧: 要删除所有"user:"开头的键,可以执行(强大的xargs)

redis-cli KEYS "user:*" | xargs redis-cli DEL

另外,由于DEL命令支持多个键作为参数,所以可以执行(性能更好)

redis-cli DEL `redis-cli KEYS "user:*"`

字符串类型

字符串类型是redis最基本的数据类型，它能存储任何形式的字符串(数字)，包括二进制数据，一个字符串类型的键允许存储的最大数据是512MB (内存总共就那么几G,一个键值就能占512MB,有点可怕)

  • 内部编码: redis使用了三种不同的编码方式来存储字符串对象，并根据字符串值自动选择

    • int: 用于能够使用64位有符号整数表示的字符串
    • embstr：用于长度小于等于44字节的字符串
    • raw：用于长度大于44字节的字符串

object命令：http://www.redis.cn/commands/object.html

# 数字带不带“”， 都是int编码
127.0.0.1:6379> set numStrK 123
OK
127.0.0.1:6379> object encoding numStrK
"int"
127.0.0.1:6379> set numStrK "123"
OK
127.0.0.1:6379> object encoding numStrK
"int"

127.0.0.1:6379> set shortStrK "shortStr"
OK
127.0.0.1:6379> object encoding shortStrK
"embstr"

127.0.0.1:6379> set longStrK "i am a long string whose length is more than 44 bytes"
OK
127.0.0.1:6379> object encoding longStrK
"raw"

  • 增

    # 赋值 SET key value
127.0.0.1:6379> set existK v
OK
127.0.0.1:6379> get existK
"v"
127.0.0.1:6379> set existK override # 覆盖已经存在的key
OK
127.0.0.1:6379> get existK
"override"

# 批量赋值(减少RTT) MSET key value [key value ...]
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3
OK
127.0.0.1:6379> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v3"

## 只新增 set + NX = insert 等价于 setNX
127.0.0.1:6379> set existK overrideAgain NX # NX: 不覆盖已存在的key(当key不存在时才设值)
(nil)
127.0.0.1:6379> get existK
"override"
127.0.0.1:6379> setnx insertK insertV
(integer) 1
127.0.0.1:6379> setnx insertK insertV
(integer) 0

## 只更新 set + XX = update
127.0.0.1:6379> set noExistK v XX # XX: 只覆盖已经存在的key(在key存在时才设值)
(nil)
127.0.0.1:6379> set existK overrideAgain XX
OK
127.0.0.1:6379> get existK
"overrideAgain"
127.0.0.1:6379> get noExistK
(nil)

# 定时过期
127.0.0.1:6379> set expKSec 5s EX 5 # 秒
OK
127.0.0.1:6379> ttl expKSec
(integer) 3
127.0.0.1:6379> ttl expKSec
(integer) 2
127.0.0.1:6379> ttl expKSec
(integer) 1
127.0.0.1:6379> ttl expKSec
(integer) -2

127.0.0.1:6379> set expKMillSec 100mills PX 100 # 毫秒
OK
127.0.0.1:6379> ttl expKMillSec
(integer) -2

# 递增: INCR key， 返回递增后的值; 键不存在,默认键值为0,进行递增
127.0.0.1:6379> get numStr
"1"
127.0.0.1:6379> incr numStr
(integer) 2
127.0.0.1:6379> get numStr
"2"

# 递增升级: INCRBY key increment， 自定义步长,可以为负数,效果等同于decrby key decrement
127.0.0.1:6379> incrby numStr 3
(integer) 5
127.0.0.1:6379> get numStr
"5"
127.0.0.1:6379> incrby numStr -2
(integer) 3
127.0.0.1:6379> get numStr
"3"

# 递增变型: INCRBYFLOAT key increment
127.0.0.1:6379> incrbyfloat numStr 0.14159267
"3.14159267"
127.0.0.1:6379> get numStr
"3.14159267"

  • 删

    # DECR key，DECR和INCR作用相反: 让键值递减
# DECRBY key decrement
# DECR没有DECRBYFLOAT, 通过INCRBYFLOAT实现相同效果
127.0.0.1:6379> incrbyfloat numStr -0.14159267
"3"
127.0.0.1:6379> get numStr
"3"
127.0.0.1:6379> decr numStr
(integer) 2
127.0.0.1:6379> get numStr
"2"
127.0.0.1:6379> decrby numStr 2
(integer) 0
127.0.0.1:6379> get numStr
"0"

  • 改

    # 追尾：APPEND key value (尾部追加值)

## 字符串 append 字符串
127.0.0.1:6379> get mystring
"stringVal"
127.0.0.1:6379> append mystring " is not enough, append str now"
(integer) 39
127.0.0.1:6379> get mystring
"stringVal is not enough, append str now"

## 数字 append 数字
127.0.0.1:6379> get numStr
"-1"
127.0.0.1:6379> append numStr 100
(integer) 5
127.0.0.1:6379> get numStr
"-1100"
127.0.0.1:6379> incr numStr
(integer) -1099

## 数字 append 字符串zifuc
127.0.0.1:6379> get numStr
"-1099"
127.0.0.1:6379> append numStr " num change to str ??"
(integer) 26
127.0.0.1:6379> get numStr
"-1099 num change to str ??"
127.0.0.1:6379> incr numStr
(error) ERR value is not an integer or out of range

# 局部修改：SETRANGE key offset value,相比于整个值覆盖，节省了RTT
127.0.0.1:6379> set myK "hello world"
OK
127.0.0.1:6379> setrange myK 6 "redis"
(integer) 11
127.0.0.1:6379> get myK 
"hello redis"
127.0.0.1:6379> setrange myK 5 @
(integer) 11
127.0.0.1:6379> getrange myK 0 -1
"hello@redis"

## 如果offset比当前key对应string还要长，那这个string后面就补0以达到offset
127.0.0.1:6379> setrange noEnoughLenK 3 value
(integer) 8
127.0.0.1:6379> get noEnoughLenK
"\x00\x00\x00value"

  • 查

    # 取值: GET key，键不存在,返回空
127.0.0.1:6379> get noExistK
(nil)
127.0.0.1:6379> get existK
"overrideAgain"

# 局部取值
127.0.0.1:6379> getrange myK 0 5
"hello "

# 取长：STRLEN key(获取字符串长度): 中文UTF-8编码,一个字符长度是3
127.0.0.1:6379> mset englishK hello chineseK 你好
OK
127.0.0.1:6379> strlen englishK 
(integer) 5
127.0.0.1:6379> strlen chineseK
(integer) 6

# 批量取值(减少RTT)：MGET key [key ...]，(同时获取多个键值)
127.0.0.1:6379> mget englishK chineseK
1) "hello"
2) "\xe4\xbd\xa0\xe5\xa5\xbd"

解决乱码： --raw
neo@neo:~$ redis-cli --raw mget englishK chineseK
hello
你好

列表类型（队列、列表）

内部使用双向链表实现, 至多包含2^32-1个元素，可以作为列表、队列、栈

  • 内部编码: redis使用quicklist存储列表，有两个配置可以调整存储逻辑

    • list-max-ziplist-size: 内部节点的最大size,一般使用默认值即可（quicklist每个节点都是一个ziplist）
    • list-compress-depth: 列表压缩策略。如果我们会用到redis队列的首尾元素，用这个配置可以获得更好的压缩比（该参数表示quicklist两端不被压缩的节点的个数，当列表很多的时候最可能被访问的数据是位于列表两端的数据，因此对这个参数进行精确调优可以实现压缩比和其他元素之间的平衡）

  • 增

    # 从列表左端插入元素： LPUSH key value [value ...]
127.0.0.1:6379> lpush lsK 1 2 3 4 5
(integer) 5
127.0.0.1:6379> lrange lsK 0 -1
1) "5"
2) "4"
3) "3"
4) "2"
5) "1"

# 从列表右端插入元素： RPUSH key value [value ...]
127.0.0.1:6379> rpush lsK -1 -2 -3 -4 -5
(integer) 10 
127.0.0.1:6379> lrange lsK 0 -1
 1) "5"
 2) "4"
 3) "3"
 4) "2"
 5) "1"
 6) "-1"
 7) "-2"
 8) "-3"
 9) "-4"
10) "-5"

# 坐标插入法：LINSERT key BEFORE|AFTER pivot value （前到后：即左到右）
## 以pivot元素为坐标,在其前面插入新元素
127.0.0.1:6379> linsert lsK before 1 66
(integer) 11
127.0.0.1:6379> lrange lsK 0 -1
 1) "5"
 2) "4"
 3) "3"
 4) "2"
 5) "66"
 6) "1"
 7) "-1"
 8) "-2"
 9) "-3"
10) "-4"
11) "-5"

## 以pivot元素为坐标,在其后面插入新元素
127.0.0.1:6379> linsert lsK after -1 -66
(integer) 12
127.0.0.1:6379> lrange lsK 0 -1
 1) "5"
 2) "4"
 3) "3"
 4) "2"
 5) "66"
 6) "1"
 7) "-1"
 8) "-66"
 9) "-2"
10) "-3"
11) "-4"
12) "-5"

# 只更新，不新增：LPUSHX,RPUSHX
# LPUSH,RPUSH,LINSERT操作不存在的key时，会自动创建，也可使用LPUSHX,RPUSHX只在key存在时操作
127.0.0.1:6379> lpushx noExistLsK 1 2 3
(integer) 0
127.0.0.1:6379> exists noExistLsK
(integer) 0
127.0.0.1:6379> rpushx noExistLsK -1 -2 -3
(integer) 0
127.0.0.1:6379> exists noExistLsK
(integer) 0

    • 删

      # 从列表左端弹出元素：LPOP key （队列式）
127.0.0.1:6379> lrange lsK 0 -1
 1) "5"
 2) "4"
 3) "3"
 4) "2"
 5) "66"
 6) "1"
 7) "-1"
 8) "-66"
 9) "-2"
10) "-3"
11) "-4"
12) "-5"
127.0.0.1:6379> lpop lsK
"5"
127.0.0.1:6379> lrange lsK 0 -1
 1) "4"
 2) "3"
 3) "2"
 4) "66"
 5) "1"
 6) "-1"
 7) "-66"
 8) "-2"
 9) "-3"
10) "-4"
11) "-5"

# 从列表左端弹出元素：RPOP key（队列式）
127.0.0.1:6379> lrange lsK 0 -1
 1) "4"
 2) "3"
 3) "2"
 4) "66"
 5) "1"
 6) "-1"
 7) "-66"range lsK 0 -1
1) "3"
2) "4"
3) "3"
4) "1"
5) "-1"
6) "-3"
7) "-4"
8) "-3"
127.0.0.1:6379> lset
 8) "-2"
 9) "-3"
10) "-4"
11) "-5"
127.0.0.1:6379> rpop lsK
"-5"
127.0.0.1:6379> lrange lsK 0 -1
 1) "4"
 2) "3"
 3) "2"
 4) "66"
 5) "1"
 6) "-1"
 7) "-66"
 8) "-2"
 9) "-3"
10) "-4"

# 阻塞版本LPOP,RPOP: BLPOP key [key ...] timeout , BRPOP key [key ...] timeout
# 在队列为空时，阻塞指定时间; （timeout，单位：秒，0表示一直阻塞）
## 一个客户端进入阻塞
127.0.0.1:6379> brpop job_queue 0
## 一个客户端压入一个元素
127.0.0.1:6379> lpush job_queue task1
(integer) 1
## 阻塞的客户端收到数据，并且退出阻塞（每次只能消费一个元素）
127.0.0.1:6379> brpop job_queue 0
1) "job_queue"
2) "task1"
(29.83s)

## 客户端进入阻塞
127.0.0.1:6379> brpop job_queue 0
## 客户端压入两个元素
127.0.0.1:6379> lpush job_queue task2 task3
(integer) 2
## 阻塞的客户端收到数据，并且退出阻塞（每次只能消费一个元素）
127.0.0.1:6379> brpop job_queue 0
1) "job_queue"
2) "task2"
(19.81s)
127.0.0.1:6379> lrange job_queue 0 -1 # 队列中还有一个元素没有消费
1) "task3"

# 删除列表中指定的值: LREM key count value
# 删除列表中前count个值为value的元素,返回值是实际删除的元素个数
##  1) count > 0, 从列表左边开始删（列表式）
127.0.0.1:6379> lrange lsK 0 -1
 1) "4"
 2) "3"
 3) "2"
 4) "66"
 5) "1"
 6) "-1"
 7) "-66"
 8) "-2"
 9) "-3"
10) "-4"
127.0.0.1:6379> lrem lsK 1 66
(integer) 1
127.0.0.1:6379> lrange lsK 0 -1
1) "4"
2) "3"
3) "2"
4) "1"
5) "-1"
6) "-66"
7) "-2"
8) "-3"
9) "-4"

##  2) count < 0, 从列表右边开始删（列表式）
127.0.0.1:6379> lrange lsK 0 -1
1) "4"
2) "3"
3) "2"
4) "1"
5) "-1"
6) "-66"
7) "-2"
8) "-3"
9) "-4"
127.0.0.1:6379> lrem lsK -1 -66
(integer) 1
127.0.0.1:6379> lrange lsK 0 -1
1) "4"
2) "3"
3) "2"
4) "1"
5) "-1"
6) "-2"
7) "-3"
8) "-4"

##  3) count = 0, 删除所有值为value的元素（列表式）
127.0.0.1:6379> lrange lsK 0 -1
 1) "3"
 2) "2"
 3) "4"
 4) "3"
 5) "2"
 6) "1"
 7) "-1"
 8) "-2"
 9) "-3"
10) "-4"
11) "-2"
12) "-3"
127.0.0.1:6379> lrem lsK 0 2
(integer) 2
127.0.0.1:6379> lrem lsK 0 -2
(integer) 2
127.0.0.1:6379> lrange lsK 0 -1
1) "3"
2) "4"
3) "3"
4) "1"
5) "-1"
6) "-3"
7) "-4"
8) "-3"

    • 改

      # 通过索引修改列表元素：LSET key index value（列表式）
127.0.0.1:6379> lrange lsK 0 -1
1) "3"
2) "4"
3) "3"
4) "1"
5) "-1"
6) "-3"
7) "-4"
8) "-3"
127.0.0.1:6379> lset lsK 0 33
OK
127.0.0.1:6379> lrange lsK 0 -1
1) "33"
2) "4"
3) "3"
4) "1"
5) "-1"
6) "-3"
7) "-4"
8) "-3"

# 裁剪列表: LTRIM key start end
# 只留下索引范围内的元素(包括start,end); 常结合LPUSH命令来限制元素数量（列表式）
# eg: LPUSH logs newLog; LTRIM logs 0 99; #每次新加入元素时调用LTRIM,来保留最新100条log
127.0.0.1:6379> lrange lsK 0 -1
1) "33"
2) "4"
3) "3"
4) "1"
5) "-1"
6) "-3"
7) "-4"
8) "-3"
127.0.0.1:6379> ltrim lsK 2 -3
OK
127.0.0.1:6379> lrange lsK 0 -1
1) "3"
2) "1"
3) "-1"
4) "-3"

# 元素转移: RPOPLPUSH source destination 【没有lpoprpush】（实现循环队列）
# 先从source右侧弹出,后从destination左侧插入(source、destination可以是同一列表)（队列式)
127.0.0.1:6379> lrange lsK 0 -1
1) "3"
2) "1"
3) "-1"
4) "-3"
127.0.0.1:6379> rpoplpush lsK lsK
"-3"
127.0.0.1:6379> lrange lsK 0 -1
1) "-3"
2) "3"
3) "1"
4) "-1"

    • 查

      # 查询列表元素个数: LLEN key
127.0.0.1:6379> lrange lsK 0 -1
1) "-3"
2) "3"
3) "1"
4) "-1"
127.0.0.1:6379> llen lsK
(integer) 4

# 获取列表片段:LRANGE key start stop, (包含两端,左端起始索引为0；右端为-1)
##  1) 如果start位置比stop靠后, 返回空列表
127.0.0.1:6379> lrange lsK 0 -1
1) "-3"
2) "3"
3) "1"
4) "-1"

## 2) 如果stop大于实际索引范围, 返回最右边元素
127.0.0.1:6379> lrange lsK 2 -3
(empty list or set)

# 通过索引查询列表元素：LINDEX key index
127.0.0.1:6379> lrange lsK 0 -1
1) "-3"
2) "3"
3) "1"
4) "-1"
127.0.0.1:6379> lindex lsK 2
"1"
127.0.0.1:6379> lindex lsK -2
"1"

集合类型

集合中元素都是唯一且无序的,一个集合类型的键可以存储至多2^32-1个字符串;
内部实现是值为空的散列表,所以增/删/判断元素是否存在,时间复杂度都是O(1);
最方便的是集合之间还可以进行并/交/差的运算

  • 内部编码

    • intset：如果元素都是整数，且元素个数小于set-max-intset-entries（默认512）配置，将采用该编码。intset对于较小的集合可以节省空间

    • hashtable: intset不适用时的默认编码

  • 集合类型和列表类型对比:

集合类型 列表类型
存储内容 至多2^32-1个字符串 至多2^32-1个字符串
有序性 否 是
唯一性 是 否

  • 增

    # 添加元素：SADD key member [member ...]
127.0.0.1:6379> sadd setK a b c
(integer) 3
127.0.0.1:6379> smembers setK
1) "b"
2) "c"
3) "a"

  • 删

    # 删除元素：SREM key member [member ...]
127.0.0.1:6379> smembers setK
1) "b"
2) "c"
3) "a"
127.0.0.1:6379> srem setK a b
(integer) 2
127.0.0.1:6379> smembers setK
1) "c"

# 弹出元素(随机：模拟随机开奖)：SPOP key [count]
127.0.0.1:6379> smembers setK
1) "b"
2) "c"
3) "a"
127.0.0.1:6379> spop setK 2
1) "b"
2) "c"
127.0.0.1:6379> smembers setK
1) "a"

  • 改

    #将member从source集合移动到destination集合中: SMOVE source destination member
127.0.0.1:6379> sscan setK1 0
1) "0"
2) 1) "1"
   2) "2"
   3) "3"
127.0.0.1:6379> sscan setK2 0
1) "0"
2) 1) "2"
   2) "3"
   3) "4"
127.0.0.1:6379> smove setK1 setK2 1
(integer) 1
127.0.0.1:6379> sscan setK1 0
1) "0"
2) 1) "2"
   2) "3"
127.0.0.1:6379> sscan setK2 0
1) "0"
2) 1) "1"
   2) "2"
   3) "3"
   4) "4"

    查

    # 获得所有元素（阻塞，不推荐）：SMEMBERS key
127.0.0.1:6379> smembers setK
1) "b"
2) "c"
3) "a"
4) "d"
5) "e"
6) "f"

# 获得所有元素（不阻塞，推荐）：SSCAN key cursor [MATCH pattern] [COUNT count]
127.0.0.1:6379> sscan setK 0 
1) "0"
2) 1) "d"
   2) "c"
   3) "f"
   4) "b"
   5) "e"
   6) "a"

# 判断元素是否存在：SISMEMBER key member
127.0.0.1:6379> smembers setK
1) "a"
127.0.0.1:6379> sismember setK q
(integer) 0
127.0.0.1:6379> sismember setK a
(integer) 1

# 获取元素个数：SCARD key
127.0.0.1:6379> smembers setK
1) "a"
127.0.0.1:6379> scard setK
(integer) 1

# 随机获取元素: SRANDMEMBER key [count]，可能返回数据并不是非常随机,为什么 => 和散列表有关
## 1) count > 0, 随机获取count个不重复元素,count大于集合元素个数,返回全部元素
127.0.0.1:6379> sadd setK a b c d e f g h i j k
(integer) 10
127.0.0.1:6379> srandmember setK 3
1) "e"
2) "f"
3) "k"
127.0.0.1:6379> srandmember setK 3
1) "d"127.0.0.1:6379> sadd setK a b c d e f g h i j k
2) "g"
3) "e"
127.0.0.1:6379> srandmember setK 3
1) "d"
2) "e"
3) "a"

## 2) count < 0, 随机获取|count|个元素,元素可能重复
127.0.0.1:6379> sadd setK a b c d e f g h i j k
(integer) 10
127.0.0.1:6379> srandmember setK -3
1) "j"
2) "j"
3) "j"
127.0.0.1:6379> srandmember setK -3
1) "j"
2) "e"
3) "d"
127.0.0.1:6379> srandmember setK -3
1) "j"
2) "a"
3) "g"

  • 集合运算

    # 并集:SUNION key [key ...], {1,2,3} U {2,3,4} = {1,2,3,4};
127.0.0.1:6379> sadd setK1 1 2 3
(integer) 3
127.0.0.1:6379> sadd setK2 2 3 4
(integer) 3
127.0.0.1:6379> sunion setK1 setK2
1) "1"
2) "2"
3) "3"
4) "4"

# 交集:SINTER key [key ...]， {1,2,3} n {2,3,4} = {2,3};
127.0.0.1:6379> sadd setK1 1 2 3
(integer) 3
127.0.0.1:6379> sadd setK2 2 3 4
(integer) 3
127.0.0.1:6379> sinter setK1 setK2
1) "2"
2) "3"

# 差集: SDIFF key [key ...]， {1,2,3} - {2,3,4} = {1}; {2,3,4} - {1,2,3} = {4};
127.0.0.1:6379> sadd setK1 1 2 3
(integer) 3
127.0.0.1:6379> sadd setK2 2 3 4
(integer) 3
127.0.0.1:6379> sdiff setK1 setK2
1) "1"
127.0.0.1:6379> sdiff setK2 setK1
1) "4"

# 并集结果存储为新key(如果key已经存在，会被覆盖), SUNIONSTORE destination key [key ...]
127.0.0.1:6379> sadd setK1 1 2 3
(integer) 3
127.0.0.1:6379> sadd setK2 2 3 4
(integer) 3
127.0.0.1:6379> sunionstore setK1UnionsetK2 setK1 setK2 
(integer) 4
127.0.0.1:6379> sscan setK1UnionsetK2 0
1) "0"
2) 1) "1"
   2) "2"
   3) "3"
   4) "4"
 
# 交集结果存储为新key(如果key已经存在，会被覆盖), SINTERSTORE destination key [key ...]
127.0.0.1:6379> sadd setK1 1 2 3
(integer) 3
127.0.0.1:6379> sadd setK2 2 3 4
(integer) 3
127.0.0.1:6379> sinterstore setK1IntersetK2 setK1 setK2  
(integer) 2
127.0.0.1:6379> sscan setK1IntersetK2 0
1) "0"
2) 1) "2"
   2) "3"

# 差集结果存储为新key(如果key已经存在，会被覆盖), SDIFFSTORE destination key [key ...]
127.0.0.1:6379> sdiffstore setK1DiffsetK2 setK1 setK2
(integer) 1
127.0.0.1:6379> sscan setK1DiffsetK2 0
1) "0"
2) 1) "1"
127.0.0.1:6379> sdiffstore setK2DiffsetK1 setK2 setK1
(integer) 1
127.0.0.1:6379> sscan setK2DiffsetK1 0
1) "0"
2) 1) "4"

有序集合

有序集合,英文名:Sorted set,意味着每个元素都有一个用于排序的权重（即为每个元素带上一个分数），虽然元素都是唯一的,但分数可以相同；这种原生有序特性使得我们可以按顺序从集合中获取元素，默认升序

  • 内部编码
    • ziplist: 对于长度小于zset-max-ziplist-entries（默认128）配置且所有元素size小于zset-max-ziplist-value配置（默认64字节）的有序集合，采用此编码。ziplist对于较小集合比较节省空间
    • skiplist: 当ziplist不适用时使用的默认编码

有序集合和列表类型对比:

  • 相同点:

    • 都是有序的
    • 都可以获取某个范围的元素

  • 不同点:

    • 列表类型是通过链表实现的,获取两端数据极快,但访问中间数据较慢. 因此更适合"新鲜事"或"日志"这样很少访问中间数据的场景
    • 有序集合是通过散列表和跳跃表(skip list)实现的,所以读取中间数据也很快: O(log(N))
    • 列表不能随意调整元素位置,但是有序集合可以(更改元素分数)
    • 有序集合比列表类型更耗费内存

  • 增

    # 添加元素：ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
# XX: 只修改元素不新增； NX: 只新增元素不修改
# CH: 让ZADD返回值为发生变化的成员总数，原始是返回新添加成员的总数 (CH 是 changed 的意思)。
# INCR: 当ZADD指定这个选项时，成员的操作就等同ZINCRBY命令，对成员的分数进行递增操作。
127.0.0.1:6379> zadd sortedsetK 1 jordan 2 kobe 3 james 4 wade 5 bosh
(integer) 5
127.0.0.1:6379> zrange sortedsetK 0 -1
1) "jordan"
2) "kobe"
3) "james"
4) "wade"
5) "bosh"
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
 1) "jordan"
 2) "1"
 3) "kobe"
 4) "2"
 5) "james"
 6) "3"
 7) "wade"
 8) "4"
 9) "bosh"
10) "5"

# 只新增元素
127.0.0.1:6379> zadd sortedsetK NX 6 culi
(integer) 1
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
 1) "jordan"
 2) "1"
 3) "kobe"
 4) "2"
 5) "james"
 6) "3"
 7) "wade"
 8) "4"
 9) "bosh"
10) "5"
11) "culi"
12) "6"
# 已经存在的元素不会被修改
127.0.0.1:6379> zadd sortedsetK NX 8 kobe
(integer) 0
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
 1) "jordan"
 2) "1"
 3) "kobe"
 4) "2"
 5) "james"
 6) "3"
 7) "wade"
 8) "4"
 9) "bosh"
10) "5"
11) "culi"
12) "6"

# 只更新
# 不存在的元素不会被新增
127.0.0.1:6379> zadd sortedsetK XX 7 durant 
(integer) 0
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
 1) "jordan"
 2) "1"
 3) "kobe"
 4) "2"
 5) "james"
 6) "3"
 7) "wade"
 8) "4"
 9) "bosh"
10) "5"
11) "culi"
12) "6"
# 为什么修改成功后，返回0，因为有序集合默认返回新增元素个数，使用ch选项可以返回被修改元素个数
127.0.0.1:6379> zadd sortedsetK XX 8 kobe
(integer) 0
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
 1) "jordan"
 2) "1"
 3) "james"
 4) "3"
 5) "wade"
 6) "4"
 7) "bosh"
 8) "5"
 9) "culi"
10) "6"
11) "kobe"
12) "8"

# CH: 修改返回值为发生变化的成员总数，原始是返回新添加成员的总数 (CH 是 changed 的意思)。更改的元素是新添加的成员，已经存在的成员更新分数。 所以在命令中指定的成员有相同的分数将不被计算在内。注：在通常情况下，ZADD返回值只计算新添加成员的数量。
127.0.0.1:6379> zadd sortedsetK ch 24 kobe
(integer) 1
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
 1) "jordan"
 2) "1"
 3) "james"
 4) "3"
 5) "wade"
 6) "4"
 7) "bosh"
 8) "5"
 9) "culi"
10) "6"
11) "kobe"
12) "24"
# 已经存在相同分数相同元素，则不算修改
127.0.0.1:6379> zadd sortedsetK ch 24 kobe
(integer) 0

# 给指定元素加分 （相当于：ZINCRBY sortedsetK 22 jordan）
127.0.0.1:6379> zadd sortedsetK incr 22 jordan
"23"
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
 1) "james"
 2) "3"
 3) "wade"
 4) "4"
 5) "bosh"
 6) "5"
 7) "culi"
 8) "6"
 9) "jordan"
10) "23"
11) "kobe"
12) "24"

# 如果元素的分值相同，按照字典顺序排序（相同元素，后面分数覆盖前面分数）
127.0.0.1:6379> zadd zsetK 0 a 0 c 0 f 0 b 0 d 2 a 2 c
(integer) 5
127.0.0.1:6379> zscan zsetK 0
1) "0"
2)  1) "b"
    2) "0"
    3) "d"
    4) "0"
    5) "f"
    6) "0"
    7) "a"
    8) "2"
    9) "c"
   10) "2"

  • 删

    # 删除元素: ZREM key member [member ...]
127.0.0.1:6379> zrem sortedsetK culi bosh
(integer) 2
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "james"
2) "3"
3) "wade"
4) "4"
5) "jordan"
6) "23"
7) "kobe"
8) "24"

# 按照排名删除元素: ZREMRANGEBYRANK key start stop
# 将指定排名(rank)区间内的元素删除。0处是分数最小的那个元素。-1是分数最大的元素。
# 删除分数最低的两个元素
127.0.0.1:6379> zremrangebyrank sortedsetK 0 1
(integer) 2
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "jordan"
2) "23"
3) "kobe"
4) "24"
# 删除最高和最低分的两个元素，需要两次操作，因为：zremrangebyrank sortedsetK 0 -1表示删除全部
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "james"
2) "3"
3) "wade"
4) "4"
5) "jordan"
6) "23"
7) "kobe"
8) "24"
# 删除最低分元素
127.0.0.1:6379> zremrangebyrank sortedsetK 0 0
(integer) 1
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "wade"
2) "4"
3) "jordan"
4) "23"
5) "kobe"
6) "24"
# 删除最高分元素
127.0.0.1:6379> zremrangebyrank sortedsetK -1 -1
(integer) 1
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "wade"
2) "4"
3) "jordan"
4) "23"

# 按照分数删除元素: ZREMRANGEBYSCORE key min max
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "james"
2) "3"
3) "wade"
4) "4"
5) "jordan"
6) "23"
7) "kobe"
8) "24"
127.0.0.1:6379> zremrangebyscore sortedsetK 1 10
(integer) 2
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "jordan"
2) "23"
3) "kobe"
4) "24"

  • 改

    # 给元素加/减分：ZINCRBY key increment member
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "james"
2) "3"
3) "wade"
4) "4"
5) "jordan"
6) "23"
7) "kobe"
8) "24"
127.0.0.1:6379> zincrby sortedsetK 3 james #加分
"6"
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "wade"
2) "4"
3) "james"
4) "6"
5) "jordan"
6) "23"
7) "kobe"
8) "24"
127.0.0.1:6379> zincrby sortedsetK -1 wade #减分
"3"
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "wade"
2) "3"
3) "james"
4) "6"
5) "jordan"
6) "23"
7) "kobe"
8) "24"

  • 查

    # 获取元素分数：ZSCORE key member
127.0.0.1:6379> zscore sortedsetK kobe
"24"

# 取分数最高的count个元素： ZPOPMAX key [count]
# 取分数最低的count个元素： ZPOPMIN key [count]
# 还有阻塞版本：BZPOPMAX key [key ...] timeout , BZPOPMIN key [key ...] timeout
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
 1) "ai"
 2) "3"
 3) "james"
 4) "3"
 5) "wade"
 6) "4"
 7) "jordan"
 8) "23"
 9) "brant"
10) "24"
11) "kobe"
12) "24"
127.0.0.1:6379> zpopmax sortedsetK 2
1) "kobe"
2) "24"
3) "brant"
4) "24"
127.0.0.1:6379> zpopmin sortedsetK 2
1) "ai"
2) "3"
3) "james"
4) "3"

# 获取某个范围的元素
# ZRANGE key start stop [WITHSCORES] #正序
# ZREVRANGE key start stop [WITHSCORES] #反序
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores 
1) "wade"
2) "3"
3) "james"
4) "6"
5) "jordan"
6) "23"
7) "kobe"
8) "24"

127.0.0.1:6379> zrevrange sortedsetK 0 -1 withscores
1) "kobe"
2) "24"
3) "jordan"
4) "23"
5) "james"
6) "6"
7) "wade"
8) "3"

# 获取指定分数范围的元素：ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
#区间：min和max可以是-inf（负无穷）和+inf（正无穷）
#默认，区间的取值使用闭区间(小于等于或大于等于)，可以使用(符号改成开区间(小于或大于)
eg: ZRANGEBYSCORE scoreboard 80 100 #[80,100]
eg: ZRANGEBYSCORE scoreboard 80 (100 #[80,100)
eg: ZRANGEBYSCORE scoreboard (80 +inf #(80,正无穷)

# 获取元素个数：ZCARD key
127.0.0.1:6379> zcard sortedsetK 
(integer) 4

# 统计某个分数范围内的元素个数：ZCOUNT key min max
127.0.0.1:6379> zcount sortedsetK 1 10
(integer) 2

# 返回指定元素区间内的元素: ZRANGEBYLEX key min max [LIMIT offset count]

# 分数必须相同! 如果有序集合中的成员分数有不一致的,返回的结果就不准。
# 成员字符串作为二进制数组的字节数进行比较。
# 默认是以ASCII字符集的排列。如果成员包含utf-8这类字符集的内容,就会影响返回结果,所以建议不要使用。
# 默认, “max” 和 “min” 参数前必须加 “[” 符号作为开头。”[” 符号与成员之间不能有空格, 返回成员结果集会包含参数 “min” 和 “max” 。
# “max” 和 “min” 参数前可以加 “(“ 符号作为开头表示小于, “(“ 符号与成员之间不能有空格。返回成员结果集不会包含 “max” 和 “min” 成员。
# 可以使用 “-“ 和 “+” 表示得分最小值和最大值
# “min” 和 “max” 不能反, “max” 放前面 “min”放后面会导致返回结果为空
# 与ZRANGEBYLEX获取顺序相反的指令是ZREVRANGEBYLEX。
# 源码中采用C语言中 memcmp() 函数, 从字符的第0位到最后一位进行排序,如果前面部分相同,那么较长的字符串比较短的字符串排序靠后
127.0.0.1:6379> zadd zset 0 a 0 aa 0 abc 0 apple 0 b 0 c 0 d 0 d1 0 dd 0 dobble 0 z 0 z1
(integer) 12
127.0.0.1:6379> zrangebylex zset - +
 1) "a"
 2) "aa"
 3) "abc"
 4) "apple"
 5) "b"
 6) "c"
 7) "d"
 8) "d1"
 9) "dd"
10) "dobble"
11) "z"
12) "z1"
127.0.0.1:6379> zrangebylex zset - + limit 0 3
1) "a"
2) "aa"
3) "abc"
127.0.0.1:6379> zrangebylex zset - + limit 3 3
1) "apple"
2) "b"
3) "c"
# 闭区间
127.0.0.1:6379> zrangebylex zset [a [c
1) "a"
2) "aa"
3) "abc"
4) "apple"
5) "b"
6) "c"
# 开区间
127.0.0.1:6379> zrangebylex zset (a (c
1) "aa"
2) "abc"
3) "apple"
4) "b"

#zrangebylex应用场景
# 电话号码排序
127.0.0.1:6379> zadd phone 0 13100111100 0 13110114300 0 13132110901
(integer) 3
127.0.0.1:6379> zadd phone 0 13200111100 0 13210414300 0 13252110901
(integer) 3
127.0.0.1:6379> zadd phone 0 13300111100 0 13310414300 0 13352110901
(integer) 3
# 获取132,133段手机号
127.0.0.1:6379> zrangebylex phone [132 (134
1) "13200111100"
2) "13210414300"
3) "13252110901"
4) "13300111100"
5) "13310414300"
6) "13352110901"
# 获取132段手机号
127.0.0.1:6379> zrangebylex phone [132 (133
1) "13200111100"
2) "13210414300"
3) "13252110901"

# 姓名排序
127.0.0.1:6379> zadd names 0 Toumas 0 Jake 0 Bluetuo 0 Gaodeng 0 Aimini 0 Aidehua
(integer) 6
127.0.0.1:6379> zrangebylex names [A (B
1) "Aidehua"
2) "Aimini"
127.0.0.1:6379> zrangebylex names [C [Z
1) "Gaodeng"
2) "Jake"
3) "Toumas"



# 获得元素的排名（正反都从0开始）
# ZRANK key member #正序
# ZREVRANK key member #反序
127.0.0.1:6379> zrange sortedsetK 0 -1 withscores
1) "wade"
2) "3"
3) "james"
4) "6"
5) "jordan"
6) "23"
7) "kobe"
8) "24"
127.0.0.1:6379> zrank sortedsetK james
(integer) 1
127.0.0.1:6379> zrevrank sortedsetK james
(integer) 2

  • 集合运算

    # 1.交集: ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]
# ZINTERSTORE命令可以计算多个有序集合的交集,并将结果存储在destination键中(同样以有序集合类型存储),返回值为destination键中的元素个数,destination键中的元素分数有AGGREGATE参数决定
#  WEIGHTS参数可以设置每个集合的权重,每个集合在运算时,元素分数会被乘上对应权重

#  1)当AGGREGATE是SUM (默认值),则相同元素,分数累加
#  2)当AGGREGATE是MIN,则相同元素,分数取小值
#  3)当AGGREGATE是MAX,则相同元素,分数取大值
127.0.0.1:6379> zrange zset1 0 -1 withscores
1) "bei"
2) "1"
3) "shang"
4) "2"
5) "guang"
6) "3"
127.0.0.1:6379> zrange zset2 0 -1 withscores
1) "guang"
2) "30"
3) "sheng"
4) "40"
5) "hang"
6) "50"
# (zset1*1) n (zset2*0.1)
127.0.0.1:6379> zinterstore zset1Interzset2 2 zset1 zset2 weights 1 0.1 aggregate sum
(integer) 1
127.0.0.1:6379> zrange zset1Interzset2 0 -1 withscores
1) "guang"
2) "6"

# 2.并集:(同交集) ZUINONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX]

# (zset1*1) U (zset2*0.1)
127.0.0.1:6379> zunionstore zset1Uionzset2 2 zset1 zset2 weights 1 0.1 aggregate sum
(integer) 5
127.0.0.1:6379> zrange zset1Uionzset2 0 -1 withscores
 1) "bei"
 2) "1"
 3) "shang"
 4) "2"
 5) "sheng"
 6) "4"
 7) "hang"
 8) "5"
 9) "guang"
10) "6"

为什么有序集合只有ZINTERSTORE / ZUINONSTORE, 而没有ZINTER / ZUNION

有序集合常用的使用场景是大数据排序: 游戏的玩家排行榜,所以很少会需要获得键中的全部数据

Redis设计者认为在做完交集 、并集后大部分情况是将结果存入新的键中以便后续处理

# 可以通过事务实现ZINTER
MULTI
ZINTERSTORE tempkey ...
ZRANGE tempkey ...
DEL tempKey
EXEC

散列类型

散列表示字段和值之间的映射关系，类型java中hashmap；为了与redis的键区分，我们使用"字段"来表示散列中值对象所关联的键，散列类型对于存储对象属性是一种完美的数据类型，至多包含2^32-1个字段

  • 内部编码

    • ziplist: 对于长度小于hash-max-ziplist-entries（默认512）配置，且所以元素size小于hash-max-ziplist-value（默认64字节）配置，采用此编码，对于较小散列对象可以节省空间
    • hashtable: 当ziplist不适用时，使用的默认编码

  • 增

    # 单字段赋值: HSET key field value （插入-返回1, 更新-返回0）
127.0.0.1:6379> hset user_1 name mike
(integer) 1
127.0.0.1:6379> hget user_1 name
"mike"
127.0.0.1:6379> hset user_1 name jordan
(integer) 0
127.0.0.1:6379> hgetall user_1
1) "name"
2) "jordan"

# 多字段赋值：HMSET key field value [field value ...]
127.0.0.1:6379> hmset user_1 sex man age 666 nickname god
OK
127.0.0.1:6379> hgetall user_1
1) "name"
2) "jordan"
3) "sex"
4) "man"
5) "age"
6) "666"
7) "nickname"
8) "god"

# 条件式新增: HSETNX key field value, 字段不存在,则新增; 字段已存在,则不做任何操作
127.0.0.1:6379> hsetnx user_1 name mk
(integer) 0
127.0.0.1:6379> hgetall user_1
1) "name"
2) "jordan"
3) "sex"
4) "man"
5) "age"
6) "666"
7) "nickname"
8) "god"
127.0.0.1:6379> hsetnx user_1 role player
(integer) 1
127.0.0.1:6379> hgetall user_1
 1) "name"
 2) "jordan"
 3) "sex"
 4) "man"
 5) "age"
 6) "666"
 7) "nickname"
 8) "god"
 9) "role"
10) "player"

# 字段递增:HINCRBY key field increment [散列类型没有HINCR命令,通过HINCRBY key field 1实现]
127.0.0.1:6379> hget user_1 age
"666"
127.0.0.1:6379> hincrby user_1 age 4
(integer) 670
127.0.0.1:6379> hget user_1 age
"670"

  • 删

    # 删除单个或多个字段：HDEL key field [field ...]
127.0.0.1:6379> hdel user_1 nickname
(integer) 1
127.0.0.1:6379> hgetall user_1
1) "name"
2) "jordan"
3) "sex"
4) "man"
5) "age"
6) "670"
7) "role"
8) "player"

  • 改

  • 查

    # 取单字段：HGET key field

# 取多字段：HMGET key field [field ...]

# 取全部字段（阻塞）：HGETALL key，

# 取全部字段（非阻塞）：HSCAN key cursor [MATCH pattern] [COUNT count]
# count指明每次希望返回元素个数，但redis不保证返回的就是count个，count的默认值是10
127.0.0.1:6379> hscan user_1 0 match n* count 10
1) "0"
2) 1) "name"
   2) "jordan"

# 只获取字段名或字段值：HKEYS key ， KVALS key
127.0.0.1:6379> hkeys user_1
1) "name"
2) "sex"
3) "age"
4) "role"
127.0.0.1:6379> hvals user_1
1) "jordan"
2) "man"
3) "670"
4) "player"

# 字段是否存在：HEXISTS key field
127.0.0.1:6379> hexists user_1 name
(integer) 1
127.0.0.1:6379> hexists user_1 address
(integer) 0

# 获取字段数量：HLEN key
127.0.0.1:6379> hlen user_1
(integer) 4

HLL类型

redis我们可以使用集合来进行唯一计数，但是，当数据量增大到上千万时，就需要考虑内存消耗和性能下降问题。如果不需要获取数据集的内容，只是想要得到不同值的个数，就可以使用HyperLogLog(HLL)数据类型来优化使用集合类型时的内存和性能问题

HLL命令都是PF开头，向HLL的发明者Philippe Flajolet致敬；HLL的优势在于能够使用固定数量的内存（每个HLL键占用12kb内存，却可以计算出最多2^64个不同元素的基数）和常数时间复杂度（每个键O(1)）进行唯一计数。不过HLL算法返回的基数可能不准确（标准差1%，HLL是cardinality counting基数计数的一种）

  • 内部编码

    HLL实际被当做字符串存储，内部使用了两种方式存储HLL对象

    • 稀疏：对于长度小于hll-sparse-max-bytes（默认3000）配置的HLL对象，采用此编码，存储效率高
    • 稠密：稀疏不适用时的默认编码
# 想要统计餐厅一个星期的独立访客数，可以每天生成一个HLL,然后用pfmerge把7天数据合并为一个
127.0.0.1:6379> pfadd myresturant_1 u1 u2 u3 u4 u5 u6 u7 u8 u9 u10
(integer) 1
127.0.0.1:6379> pfadd myresturant_2 u6 u7 u8 u9 u10 u11 u12 u13 u14 u15
(integer) 1
127.0.0.1:6379> pfadd myresturant_3 u1 u2 u3 u4 u5 u10 u20 u30 u40 u50
(integer) 1
127.0.0.1:6379> pfmerge myresturant_week myresturant_1 myresturant_2 myresturant_3
OK
127.0.0.1:6379> pfcount myresturant_week
(integer) 19

GEO类型

排序

SORT命令可对列表类型、集合类型、有序集合类型进行排序，可完成与关系数据库中的连接查询相类似的任务

# 对集合进行排序
127.0.0.1:6379> SADD uid 6 12 66 86 70 2
(integer) 6
127.0.0.1:6379> SORT uid
1) "2"
2) "6"
3) "12"
4) "66"
5) "70"
6) "86"
# 当集合元素都是整数，Redis第这种情况进行了优化：元素是有序的
127.0.0.1:6379> SMEMBERS uid
1) "2"
2) "6"
3) "12"
4) "66"
5) "70"
6) "86"

# 对列表进行排序
127.0.0.1:6379> LPUSH ls 4 2 6 1 3 7
(integer) 6
127.0.0.1:6379> LRANGE ls 0 -1
1) "7"
2) "3"
3) "1"
4) "6"
5) "2"
6) "4"
127.0.0.1:6379> SORT ls
1) "1"
2) "2"
3) "3"
4) "4"
5) "6"
6) "7"
#（结合前面的LRANGE结果，可以看出SORT并不会影响原列表）
127.0.0.1:6379> LRANGE ls 0 -1
1) "7"
2) "3"
3) "1"
4) "6"
5) "2"
6) "4"

# 对字符进行排序，要加上ALPHA参数
127.0.0.1:6379> LPUSH ls2 a c e d B C A
(integer) 7
127.0.0.1:6379> LRANGE ls2 0 -1
1) "A"
2) "C"
3) "B"
4) "d"
5) "e"
6) "c"
7) "a"
127.0.0.1:6379> SORT ls2
(error) ERR One or more scores can't be converted into double
127.0.0.1:6379> SORT ls2 ALPHA
1) "a"
2) "A"
3) "B"
4) "c"
5) "C"
6) "d"
7) "e"

# 反序
127.0.0.1:6379> SORT uid DESC
1) "86"
2) "70"
3) "66"
4) "12"
5) "6"
6) "2"
127.0.0.1:6379> SORT ls2 ALPHA DESC
1) "e"
2) "d"
3) "C"
4) "c"
5) "B"
6) "A"
7) "a"

# LIMIT offset count (top3)
127.0.0.1:6379> SORT ls DESC
1) "7"
2) "6"
3) "4"
4) "3"
5) "2"
6) "1"
127.0.0.1:6379> SORT ls DESC LIMIT 0 3
1) "7"
2) "6"
3) "4"
127.0.0.1:6379>

限制

key：512MB

String类型：一个String类型的value最大可以存储512M

List类型：list的元素个数最多为2^32-1个，也就是4294967295个。

Set类型：元素个数最多为2^32-1个，也就是4294967295个。

Hash类型：键值对个数最多为2^32-1个，也就是4294967295个。

Sorted set类型：跟Set类型一致

问题

1、为什么redis基本类型里没有数字类型

2、为什么有set类型还要有HyperLogLog

3、如何利用redis实现循环队列

4、如何利用redis实现随机开奖

5、为什么有序集合修改成功后，返回0

6、删除有序集合分数最高和最低两个元素可以一次操作完成吗

7、为什么有序集合只有ZINTERSTORE / ZUINONSTORE, 而没有ZINTER / ZUNION

你可能感兴趣的:(redis第三章：数据结构)

  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 小说《灰色年代》第三章、书中自有黄金屋/第二节（1）/作者:邵明 房作者_0970
    ——第三章、第二节、科举与国考（1）科举制的简介：科举制度是古代读书人，参加选拔考试的制度，它是历代通过考试选拔官吏的一种手段，由于采用分科取士的办法，所以叫做科举。科举制从隋代开始实行，到清光绪三十一年（1905年）举行最后一科进士考试为止，经历了1300年，1905年9月2日，清政府废除科举制度。科举考前三名，分别为状元、榜眼、探花。这种划分和称谓是在元朝时确定下来的，明清时期沿袭了元朝的这种
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构leetcode算法
    给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 华为云分布式缓存服务DCS 8月新特性发布 华为云PaaS服务小智 华为云分布式缓存
    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
  • 6.0 践行打卡 D47 星月格格
    去努力改变1.运动步行13000+8分钟腿部拉伸2.阅读《墨菲定律》第三章第三节:霍桑效应～适度发泄，才能轻装上阵“霍桑效应”这一概念，源自于1924年一个1933年间以哈佛大学心理专家乔治·埃尔顿·梅奥教授为首进行的一系列工厂工人的谈话实验研究。“霍桑效应”告诉我们，在工作，生活中总会产生数不清的情绪反应，其中很大一部分是负面的负面情绪的积累会影响人的精神和心情，不仅仅会影响个人健康，还会破坏人
  • Redis Key的过期策略 ArchManual 分布式架构分布式Java后端微服务架构redis
    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
  • Redis:缓存击穿 我的程序快快跑啊 缓存redisjava
    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
  • 【高阶数据结构】并查集 椿融雪 数据结构与算法数据结构并查集
    文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
  • Redis 有哪些危险命令？如何防范？ 花小疯 redis缓存数据库危险命令大数据
    Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • 六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
    数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
  • Golang Channel PandaSkr golang
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表 英雄哪里出来 《LeetCode算法全集》算法数据结构链表c++归并排序
    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
  • 数据结构 1 五花肉村长 数据结构算法开发语言c语言visualstudio
    1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理 朱杰jjj 缓存分布式
    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
  • Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商 weixin_34302561 数据库devops大数据
    1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
  • 关于旗正规则引擎中的MD5加密问题 何必如此 jspMD5规则加密
    一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。 在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 2.在规
  • 【Spark101】Scala Promise/Future在Spark中的应用 bit1129 Promise
    Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
  • spark sql 访问hive数据的配置详解 daizj spark sqlhivethriftserver
    spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下：   1、下载源码   2、下载Maven,并配置 此配置简单，就略过
  • HTTP 协议通信 周凡杨 javahttpclienthttp通信
                            一：简介  HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！     二： 代码举例      测试类： import java
  • java unix时间戳转换 g21121 java
    把java时间戳转换成unix时间戳： Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())) SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
  • web报表工具FineReport常用函数的用法总结（报表函数） 老A不折腾 web报表finereport总结
    说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。   CLASS CLASS(object):返回object对象的所属的类。   CNMONEY CNMONEY(number,unit)返回人民币大写。 number:需要转换的数值型的数。 unit:单位，
  • java jni调用c++ 代码 报错 墙头上一根草 javaC++jni
    # # A fatal error has been detected by the Java Runtime Environment: # #  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 # # JRE version: Java(TM) SE Ru
  • Spring中事件处理de小技巧 aijuans springSpring 教程Spring 实例Spring 入门Spring3
    Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
  • linux shell ls脚本样例 annan211 linuxlinux ls源码linux 源码
    #! /bin/sh - #查找输入文件的路径 #在查找路径下寻找一个或多个原始文件或文件模式 # 查找路径由特定的环境变量所定义 #标准输出所产生的结果 通常是查找路径下找到的每个文件的第一个实体的完整路径 # 或是filename :not found 的标准错误输出。 #如果文件没有找到 则退出码为0 #否则 即为找不到的文件个数 #语法 pathfind [--
  • List,Set,Map遍历方式 (收集的资源,值得看一下) 百合不是茶 listsetMap遍历方式
    List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
  • 解决SimpleDateFormat的线程不安全问题的方法 bijian1013 javathread线程安全
    在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： public class DateUtil01 { private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void format(Date d
  • http请求测试实例（采用fastjson解析） bijian1013 http测试
            在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 import java.util.HashMap; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import
  • 【RPC框架Hessian三】Hessian 异常处理 bit1129 hessian
    RPC异常处理概述   RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？   如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。   在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
  • 【日志分析】日志分析工具 bit1129 日志分析
    1. 网站日志实时分析工具 GoAccess http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 3.log.io 和
  • nginx优化加强战斗力及遇到的坑解决 ronin47 nginx 优化
    　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。 　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。   　　　来以下优化：   　　　
  • java-50-输入两棵二叉树A和B，判断树B是不是A的子结构 bylijinnan java
    思路来自： http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ import ljn.help.*; public class HasSubtree { /**Q50. * 输入两棵二叉树A和B，判断树B是不是A的子结构。 例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
  • mongoDB 备份与恢复 开窍的石头 mongDB备份与恢复
    Mongodb导出与导入 1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通用选项: -h host   主机 --port port    端口 -u username 用户名 -p passwd   密码 2: mongoexport 导出json格式的文件
  • [网络与通讯]椭圆轨道计算的一些问题 comsci 网络
         如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。       也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
  • 软件专利如何申请 cuiyadll 软件专利申请
    软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
  • Android学习笔记 darrenzhu android
    1.启动一个AVD 2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 3.如何启动一个程序   am start -n package name/.activityName   am start -n com.example.helloworld/.MainActivity 启动Android设置工具的命令如下所示： # am start -
  • apache虚拟机配置，本地多域名访问本地网站 dcj3sjt126com apache
    现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。 现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 1、首先修改C盘WINDOWS\system32\drivers\etc目录下的
  • yii2 restful web服务[速率限制] dcj3sjt126com PHPyii2
    速率限制 为防止滥用，你应该考虑增加速率限制到您的API。 例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。 如果一个用户同一个时间段内太多的请求被接收， 将返回响应状态代码 429 (这意味着过多的请求)。 要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
  • Hadoop2.5.2安装——单机模式 eksliang hadoophadoop单机部署
    转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述        Hadoop有三种模式 单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式 ，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。   二、下载地址 Hadoop 网址http:
  • LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构 gundumw100 android
    一切为了快速迭代 import java.util.ArrayList; import org.json.JSONObject; import android.animation.ObjectAnimator; import android.os.Bundle; import android.support.v4.widget.SwipeRefreshLayo
  • 三道简单的前端HTML/CSS题目 ini htmlWeb前端css题目
    使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（ ）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm   在HTML中加入<table style=”color:red; font-size:10pt”>，此为（ ）。http://hovertree.com/s
  • overrided方法编译错误 kane_xie override
    问题描述： 在实现类中的某一或某几个Override方法发生编译错误如下： Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it   当去掉@Over
  • Java中使用代理IP获取网址内容（防IP被封，做数据爬虫） mcj8089 免费代理IP代理IP数据爬虫JAVA设置代理IP爬虫封IP
    推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/   Java语言有两种方式使用代理IP访问网址并获取内容，   方式一，设置System系统属性   // 设置代理IP System.getProper
  • Nodejs Express 报错之 listen EADDRINUSE qiaolevip 每天进步一点点学习永无止境nodejs纵观千象
    当你启动 nodejs服务报错： >node app Express server listening on port 80 events.js:85 throw er; // Unhandled 'error' event ^ Error: listen EADDRINUSE at exports._errnoException (
  • C++中三种new的用法 _荆棘鸟_ C++new
    转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 作者: mt 其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： string* ps = new string("
  • Ruby深入研究笔记1 wudixiaotie Ruby
    module是可以定义private方法的 module MTest def aaa puts "aaa" private_method end private def private_method puts "this is private_method" end end
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他