第1篇 基础和应用篇 / 1/ K6 |+ H& y4 c2 i
1.1 授人以鱼不如授人以渔 / 1
- l/ b; _9 F- j1.1.1 由 Redis 面试想到的 / 1
4 M3 @/ f8 q/ c- G" v1 O1.1.2 本书的内容范围 / 2
0 n2 H6 s, I* g0 R' ^4 k. ?, z0 c1.1.3 Redis 可以做什么 / 3
$ T/ T* w4 g3 L3 G- r1.1.4 小结 / 3& r- I' m" `9 Z7 S, w
1.1.5 扩展阅读 / 4
i$ x6 [' l& s7 o1.2 万丈高楼平地起——Redis 基础数据结构 / 4$ O- [6 f2 u& Z9 C) ?
1.2.1 Redis 的安装 / 51 A( k A8 y5 k. f/ r* C+ F; u
1.2.2 5 种基础数据结构 / 6
* b( N; H/ T$ y# R1.2.3 容器型数据结构的通用规则 / 17& g& a* e& O+ i2 n+ c' ^" O
1.2.4 过期时间 / 17( `: a9 T& j7 B) g7 D1 ?: g
1.2.5 思考＆作业 / 17* a& m, Z" l/ M" J& V5 }: w
1.3 千帆竞发——分布式锁 / 18: P: X2 l: y: R& m8 _ b
1.3.1 分布式锁的奥义 / 18: l( ^% l0 i; t4 I5 x$ T" M# a
1.3.2 超时问题 / 20
% k6 U4 j& A2 X, c1.3.3 可重入性 / 21
0 ]! v) y5 ?" a7 Q9 j' M1 E/ W. {1.3.4 思考＆作业 / 248 x H( f4 e* L$ @+ D8 [4 _$ j
1.4 缓兵之计——延时队列 / 24
: o1 R0 Y0 [' l7 L( r" o, @' ?" ]1.4.1 异步消息队列 / 24% f5 i7 D) Y' f1 {: ~: H
1.4.2 队列空了怎么办 / 26
. X$ j2 |' l) g4 W; I9 J1.4.3 阻塞读 / 26) a2 i; T) O8 h1 S" ]3 g0 Y, K) w
1.4.4 空闲连接自动断开 / 26
! g" a+ P8 H5 U6 D T) _" D3 w1.4.5 锁冲突处理 / 279 @$ b% D/ ~' ~) z* Y5 c: }6 ]+ f% ]# N
1.4.6 延时队列的实现 / 27
: S( q4 x. F4 v/ N; _1.4.7 进一步优化 / 30
& a8 n3 r9 x! l- L, L1.4.8 思考＆作业 / 314 m5 P7 j5 b+ {" I) I1 `
1.5 节衣缩食——位图 / 310 C3 m: z j) j$ Q
1.5.1 基本用法 / 31
, i& p- W) p$ C0 O# f- y& p1.5.2 统计和查找 / 341 L: T8 [# {. J# w: e y, \
1.5.3 魔术指令 bitfield / 35
0 }! G% p; {4 \: ^) }1.5.4 思考＆作业 / 38
9 ^- s! a& w- C5 Z7 C" b5 d9 o1.6 四两拨千斤——HyperLogLog / 38
$ J; T1 F+ Z6 n1.6.1 使用方法 / 390 O f: G2 @, W o: I. N
1.6.2 pfadd 中的 pf 是什么意思 / 41
% m/ Z. s+ V6 u! ~. ]0 X: u+ _1.6.3 pfmerge 适合的场合 / 42" q9 ]+ }4 g9 c/ Q+ r
1.6.4 注意事项 / 42
9 V1 S" W; v' P1.6.5 HyperLogLog 实现原理 / 42) i9 o: ~- V2 L
1.6.6 pf 的内存占用为什么是 12KB / 49) g: u6 i5 ?0 K* k7 h- v; W6 u S
1.6.7 思考＆作业 / 50
, B( i( K% M5 I; i6 z5 t& A( I1.7 层峦叠嶂——布隆过滤器 / 50
- G) b' N5 @% w6 }7 c) v) r1.7.1 布隆过滤器是什么 / 51, F2 x/ r f' i6 ~, d$ q0 w# [
1.7.2 Redis 中的布隆过滤器 / 51
3 B5 u5 Z$ P( i9 t1.7.3 布隆过滤器的基本用法 / 52( Z7 n* q, K" u* l. [; h' R. c( Z. K
1.7.4 注意事项 / 594 p1 t0 u3 x. i) L) |% v0 ^
1.7.5 布隆过滤器的原理 / 60
; u0 v+ q, u- A: a: ~1.7.6 空间占用估计 / 61
" q6 _6 i( _4 ?- C; _1 }- m0 t1.7.7 实际元素超出时，误判率会怎样变化 / 62
8 U. X) O1 F3 ~% P! D/ P, O1.7.8 用不上 Redis 4.0 怎么办 / 635 F4 B* p) e$ A) I$ l( e8 h! f
1.7.9 布隆过滤器的其他应用 / 63' a0 C6 p% g R8 l
1.8 断尾求生——简单限流 / 64
- t+ }. Y3 l4 f* y1.8.1 如何使用 Redis 来实现简单限流策略 / 64+ o; p+ H! K. r) E) m) \$ w
1.8.2 解决方案 / 651 u0 `* }" t5 j$ k) P6 U
1.8.3 小结 / 676 n$ \# y2 c( q
1.9 一毛不拔——漏斗限流 / 68$ h% \1 S# ^4 z
1.9.1 Redis-Cell / 71
) S \8 c* Z9 }1.9.2 思考＆作业 / 72
' C) s6 w0 Y( _8 D! l1 j1.9.3 扩展阅读：Redis-Cell 作者介绍 / 72
7 G2 m/ T( p" f* l7 E$ [1.10 近水楼台——GeoHash / 73# C9 Y) O0 A* a) f( N X" C
1.10.1 用数据库来算附近的人 / 739 c3 V( Q; F( V
1.10.2 GeoHash 算法 / 74
4 m# S# e% o: _( I& L1.10.3 Geo 指令的基本用法 / 75
% b5 g5 P# j2 m$ t3 H$ \: l1.10.4 注意事项 / 78
3 n* V. w/ D* Q4 y1.11 大海捞针——scan / 79* _1 I; }/ Q3 \2 ]# D$ G, D7 z- ^: |- _! y
1.11.1 scan 基本用法 / 80
- P4 X l% `2 M" F+ C1.11.2 字典的结构 / 82
# r. K! _# |" B1 s( A- Z1.11.3 scan 遍历顺序 / 82
) q2 Q% _' \8 I8 i4 }' o: A1.11.4 字典扩容 / 83
. q: _5 j/ u; r5 h1.11.5 对比扩容、缩容前后的遍历顺序 / 84
$ ?* \$ l1 m- [# s& ?/ E1.11.6 渐进式 rehash / 85
' ^- S' O. ~4 x3 y! Z: f1.11.7 更多的 scan 指令 / 85
3 m7 k" Z, W- w8 N/ H) U1.11.8 大 key 扫描 / 854 V4 r" h3 Z# |0 s B8 g* E+ }
第2 篇 原理篇 / 87' Y- a' N/ o) u5 F/ _
2.1 鞭辟入里——线程 IO 模型 / 87
) u* I! a! a- B. B% {" Z4 j2.1.1 非阻塞 IO / 87% x; r, F }( K- s- P b& h
2.1.2 事件轮询 （多路复用） / 88
' S/ u3 S4 i) `9 N1 j* ` }# b2.1.3 指令队列 / 90
' z1 O& o$ h2 W1 v3 Z( O8 o2.1.4 响应队列 / 90, a% L" v2 j5 I. t
2.1.5 定时任务 / 90. W( \5 w9 j( I) [, K
2.1.6 扩展阅读 / 90
8 P k& u* x2 [" V2.2 交头接耳——通信协议 / 90. w& r ^; i# M' P
2.2.1 RESP / 914 L* v3 o6 ~* w t
2.2.2 客户端→服务器 / 92. R' a+ p5 L9 M# N l! O
2.2.3 服务器→客户端 / 92
* J7 ?' \' d/ m! R% f2.2.4 小结 / 95
9 U. |, W( h/ @2.2.5 扩展阅读 / 95; i5 F, v: V o3 A5 U
2.3 未雨绸缪——持久化 / 95- {2 c1 L0 Z4 }! D! `) E/ U8 j
2.3.1 快照原理 / 96
" \; q s0 Y- X2.3.2 fork（多进程） / 969 f7 @5 a( q3 Z
2.3.3 AOF 原理 / 97
: t# m- g% J3 M8 E/ @7 U2.3.4 AOF 重写 / 98
+ d" Y J% X( ?6 s Q$ T2.3.5 fsync / 98. a% p5 _0 s! }+ W9 E& w( }9 ?
2.3.6 运维 / 98' D* n/ q! c6 a' g9 L2 V
2.3.7 Redis 4.0 混合持久化 / 99- K/ q8 C ^* w9 |' S
2.3.8 思考＆作业 / 1008 C' @0 Y4 Q& Q( ~% e4 F1 M7 z
2.4 雷厉风行——管道 / 100' u/ R, U' H) V! z- X3 l2 M
2.4.1 Redis 的消息交互 / 100; V6 v- X. ^2 s1 X# t. v7 |
2.4.2 管道压力测试 / 101( ?( h/ F# {# p* t# e
2.4.3 深入理解管道本质 / 102
/ { H: U7 c5 j5 q2.4.4 小结 / 104
U6 W6 v, J4 u( ?, |! \0 |, n2.5 同舟共济——事务 / 104
$ O M( P2 S( w- I' d2.5.1 Redis 事务的基本用法 / 104 V1 t* G: |, t! p9 F0 \+ X( u5 \
2.5.2 原子性 / 105
* t b- f# d" Y6 d' ~% d2.5.3 discard（丢弃） / 1069 Q/ n+ j k( K6 M! f% [8 @
2.5.4 优化 / 106- H3 ^$ N3 Y: L! m2 ]. i U# _
2.5.5 watch / 107
; U5 Y e. w, P5 v0 r S2.5.6 注意事项 / 108
6 l$ S6 c& P6 J" }5 s, [2.5.7 思考＆作业 / 110
# t$ [; b; s P9 n: h2.6 小道消息——PubSub / 110
7 D0 G! w- O1 I- p: c% U: y* Q2.6.1 消息多播 / 110- ?! C' [$ y* B+ i3 o$ }3 ?
2.6.2 PubSub / 1111 s% d& c- a5 u6 v1 t c4 r
2.6.3 模式订阅 / 113# i: u( r9 n: M( W% d7 \( y3 w
2.6.4 消息结构 / 114( g3 h" E2 F& j
2.6.5 PubSub 的缺点 / 115/ C0 N* `0 D H. V2 d* i
2.6.6 补充 / 115; p/ L" E& q' t, g4 Q
2.7 开源节流——小对象压缩 / 115
& b& f0 U0 B& r! O$ ~3 S2.7.1 32bit VS 64bit / 116
. D9 n4 R5 D" p0 j {3 g ~( ^2.7.2 小对象压缩存储（ziplist） / 116
' H, r x% o2 @) H1 e( F2 v0 }2.7.3 内存回收机制 / 120
% ~! c4 G4 X. h+ E. y/ ^2.7.4 内存分配算法 / 120
4 E% s& z4 b7 A; q: ^第3 篇 集群篇 / 1226 z6 j. e6 t0 }, _. T! l
3.1 有备无患——主从同步 / 122$ y. u: X; q5 i4 ^$ a. k z
3.1.1 CAP 原理 / 122
5 Z: }$ `& `( j% [3.1.2 终一致 / 1232 _0 [* K8 [ P) _, G$ ^
3.1.3 主从同步与从从同步 / 123
0 M* C1 l8 S& P* J8 Y% D( i3.1.4 增量同步 / 124
* h$ u% C) ^' i3 ~4 [3.1.5 快照同步 / 124* k: o& x2 G3 z3 ~. x
3.1.6 增加从节点 / 125& a$ {9 w+ x( k- h
3.1.7 无盘复制 / 125! g$ P3 }/ k/ n& \: c) R6 b6 d
3.1.8 wait 指令 / 125
* u" S+ } L% g* t$ K* G3.1.9 小结 / 126
) k) h7 T- f; \) B3.2 李代桃僵——Sentinel / 1268 t9 N. Y. t( u/ x# f1 O' r; a; b
3.2.1 消息丢失 / 128& o9 X a. m3 Q% [9 K0 i. r
3.2.2 Sentinel 基本用法 / 1286 @" ~* \3 g: a' i( T' Y
3.2.3 思考＆作业 / 129
* V% X8 A0 t7 P( ], ^3.3 分而治之——Codis / 130) ?& y3 E0 ?6 t
3.3.1 Codis 分片原理 / 1313 U2 Y( U+ _0 [0 S- ^( \. l- I
3.3.2 不同的 Codis 实例之间槽位关系如何同步 / 132
' T6 Z# W2 }- c9 O4 s6 I3.3.3 扩容 / 132( `, r# o% U5 [+ [7 |+ ]0 I+ l
3.3.4 自动均衡 / 133
! p. S! n6 h% j3.3.5 Codis 的代价 / 133
+ v' ?9 \6 g" k: p2 R3.3.6 Codis 的优点 / 134+ @" L, Y0 y7 u, T
3.3.7 mget 指令的操作过程 / 134& X3 Y2 _# z; Q# q+ H3 [
3.3.8 架构变迁 / 135+ Q' {, [) u# p* W
3.3.9 Codis 的尴尬 / 135
" i7 t: g" M5 |' h2 W. x% B/ S, d3.3.10 Codis 的后台管理 / 136
z% N, F z5 q( S% s4 G3.3.11 思考＆作业 / 136# v, d' A* ?# q
3.4 众志成城——Cluster / 1378 i0 S4 t+ D) n" B, J5 x" e
3.4.1 槽位定位算法 / 138
+ _" F* M3 r% X# E8 r2 h7 D3.4.2 跳转 / 138% r; [' x M- H$ a
3.4.3 迁移 / 138: j8 f" n4 {& I+ p% M4 c" n) C6 f& ~
3.4.4 容错 / 140
3 c8 `1 v5 h# g' m# F3 `8 ]3.4.5 网络抖动 / 140
0 r1 H2 k$ L5 c: A+ B" Z( t2 s( C3.4.6 可能下线（PFAIL）与确定下线（Fail） / 141
# V! h7 B: [, u% ^7 Q, C* F3.4.7 Cluster 基本用法 / 141
6 U5 F+ ?9 \7 b4 a/ E3 {* _! x Z! P$ I3.4.8 槽位迁移感知 / 142$ w6 g/ G$ Q) r" v
3.4.9 集群变更感知 / 143; U; R; S5 g) l0 y
3.4.10 思考＆作业 / 143
+ P; Z+ S& F7 J, h& F第4 篇 拓展篇 / 1447 k6 Q1 |. A/ T3 `1 R: b$ ^) C# {! B& [. S
4.1 耳听八方——Stream / 144* e- l5 Y: u4 K1 M% \3 ~
4.1.1 消息 ID / 1450 Y) w j" O, A5 h+ D! @; x# A$ k
4.1.2 消息内容 / 1456 f/ \) R& M5 T& O4 ^
4.1.3 增删改查 / 145
. m% J$ ~1 K1 P) `& @; I' w6 W) C4.1.4 独立消费 / 147
# i; ]4 _7 }7 _3 P" l4.1.5 创建消费组 / 148, M# |0 ]$ ?: |2 O& `
4.1.6 消费 / 150' t0 t, P0 q$ @1 h2 D \4 l6 M G
4.1.7 Stream 消息太多怎么办 / 152
4 L) J+ }( E. p- G4.1.8 消息如果忘记 ack 会怎样 / 153, j2 i) O% l$ X6 M" G
4.1.9 PEL 如何避免消息丢失 / 153
|5 P( G) B6 [& ~$ H; d8 X4.1.10 Stream 的高可用 / 153
% q; _6 F5 `* Y: t0 ?7 f$ a4.1.11 分区 Partition / 1543 S9 q9 m: d) y* k. C2 k9 `
4.1.12 小结 / 154: t# r" J" V4 N7 {# C2 |9 I
4.2 无所不知——Info 指令 / 1541 y1 B+ o) g6 i! X
4.2.1 Redis 每秒执行多少次指令 / 155
5 Z& _0 b* ? H3 M* i5 R. H, p% ?. @4.2.2 Redis 连接了多少客户端 / 156
5 U! |# F3 A; U# @# A1 r4.2.3 Redis 内存占用多大 / 1569 L1 ?7 ~4 S: ]2 y+ M
4.2.4 复制积压缓冲区多大 / 157
4 G# J7 g& b, F6 S* ^8 \4.2.5 思考＆作业 / 158" ^" R4 R- L) y+ B2 [
4.3 拾遗补漏——再谈分布式锁 / 158# b" l+ s2 T! @9 B6 _ S. p
4.3.1 Redlock 算法 / 158
' R1 L5 Z3 {5 S. |+ O4.3.2 Redlock 使用场景 / 159
/ D g+ E( v/ h6 Q. Q- P: Z4.3.3 扩展阅读：redlock-py 的作者 / 160
. G8 z4 L w/ j( y5 x) b4.4 朝生暮死——过期策略 / 1606 t% X8 B* w# Y( Z$ p9 D. j# X
4.4.1 过期的 key 集合 / 160
, i$ h/ Y+ ^' b4.4.2 定时扫描策略 / 160
( @1 ]- A0 E, C9 D4.4.3 从节点的过期策略 / 1619 {) K" G% X9 A6 S; C' p" n
4.5 优胜劣汰——LRU / 162
7 M6 B B, {' e4.5.1 LRU 算法 / 163
0 f0 R/ N* ^4 Y3 ?4.5.2 近似 LRU 算法 / 164' D8 t7 o! M- n; f# R- j
4.5.3 思考＆作业 / 165
1 A0 z- T% U5 t$ F" e4.6 平波缓进——懒惰删除 / 165
5 T, k# z9 x7 [4.6.1 Redis 为什么使用懒惰删除 / 165$ X6 Q1 A( ?$ U
4.6.2 flush / 1660 Q$ Z" A6 R+ e& C4 R1 @; a# O# U
4.6.3 异步队列 / 1663 @3 [$ k* v& A4 E/ N q5 g" G
4.6.4 AOF Sync 也很慢 / 166% [2 w' }) i0 r. S% ?9 T
4.6.5 更多异步删除点 / 1665 u e9 }1 ?( T8 ?5 c
4.7 妙手仁心——优雅地使用 Jedis / 167
; ?2 s$ n4 @8 i: ^- r4.7.1 重试 / 1710 V9 f$ ^3 j4 @5 D" k5 ~
4.7.2 思考＆作业 / 172
: o# R' O# \- T/ Q% y4.8 居安思危——保护 Redis / 172
" Z" O! f9 o6 b- ]! I/ t3 a4.8.1 指令安全 / 172; B8 b4 \- M, c
4.8.2 端口安全 / 173
+ Y- o2 B: O! T6 K; m1 i4.8.3 Lua 脚本安全 / 174
8 i: S7 b q" e4.8.4 SSL 代理 / 174! ~5 L% p) M+ H2 b$ _
4.8.5 小结 / 174 G* t" p: V3 K( s j
4.9 隔墙有耳——Redis 安全通信 / 175
* D' P0 j/ x0 v6 Y, [, [6 D$ n2 |& v& ~4.9.1 spiped 原理 / 176
& Y5 q& V. } q1 I0 F4.9.2 spiped 使用入门 / 176
# S/ s6 C$ E% c4.9.3 思考＆作业 / 179
+ Z1 U# V' i3 u5 N; }8 J第5 篇 源码篇 / 1803 {, ~3 _1 x' P- _2 V( x; \
5.1 丝分缕析——探索“字符串”内部 / 180
1 s5 @6 S. c8 r* O8 T5.1.1 embstr VS raw / 181
, ?. j" Y/ _3 ^! d5.1.2 扩容策略 / 184
# a' z( B8 z) }" K4 }5.1.3 思考＆作业 / 184
9 Q% B- l$ L& N5.2 循序渐进——探索“字典”内部 / 184
1 s l" _, z8 ]# o2 {5.2.1 dict 内部结构 / 184
& f1 G0 ?- l7 b) o5 k5.2.2 渐进式 rehash / 1863 z" h: D( |2 q
5.2.3 查找过程 / 1876 y: Y; k3 m9 O1 |0 w$ [
5.2.4 hash 函数 / 188/ S, [+ n) T* j5 L% i
5.2.5 hash 攻击 / 188
# t. A1 n) W( _0 v ^ P5.2.6 扩容条件 / 188, C. G$ r+ }7 s$ m' ^' Z- e
5.2.7 缩容条件 / 189& V) n6 l* Q5 t$ D$ [$ i5 g
5.2.8 set 的结构 / 189
$ [2 g# ]. A* h- b2 V5.2.9 思考＆作业 / 1890 B7 Y$ q9 A# j1 O. U2 r
5.3 挨肩迭背——探索“压缩列表”内部 / 1907 f1 [8 z) A" F% t2 [$ S5 F
5.3.1 增加元素 / 192% S! H2 k7 h; u) a
5.3.2 级联更新 / 192
Q4 p: a3 K! A! R2 F) D% `" a# c5.3.3 intset 小整数集合 / 194
" e! B$ n7 |" G9 ?$ x- @6 z5.3.4 思考＆作业 / 195
. A ~% d! C$ `% H a) Y5.4 风驰电掣——探索“快速列表”内部 / 195: U8 `. ^8 \2 H) v t' {
5.4.1 每个 ziplist 存多少元素 / 197
. ]$ I y: X5 O6 b5.4.2 压缩深度 / 198
& \4 Y# J' ^0 Z. @) |0 v+ Z5.5 凌波微步——探索“跳跃列表”内部 / 198
# B. f) @8 A$ X) v- i% ^5.5.1 基本结构 / 1997 X2 l# w0 k0 P1 O" c
5.5.2 查找过程 / 199
' D' ]" n8 h% q6 G; b8 ]* Z6 z" ]6 p/ x5.5.3 随机层数 / 200
: E& l/ q# P9 j$ u$ X; y5.5.4 插入过程 / 2012 E7 e) g$ i! D+ ^" J
5.5.5 删除过程 / 2029 ^- \9 G4 q- V& Q7 l
5.5.6 更新过程 / 203
- ]7 U1 i7 h! f3 [. B2 I0 \5.5.7 如果 score 值都一样呢 / 203* Z! T( t' J1 Y6 p. r8 @/ u0 H
5.5.8 元素排名是怎么算出来的 / 203; F9 Y! x* `4 c$ e2 v' [2 B
5.5.9 思考＆作业 / 204
: @8 [1 Z- ?# D( q; A5.5.10 题外话 / 204
3 e% s# W) b; y) }5.6 破旧立新——探索“紧凑列表”内部 / 205, \% |0 o$ O. `; @7 l. ~
5.6.1 级联更新 / 207
/ \( P3 [4 s$ E: H! ^5.6.2 取代 ziplist 尚需时日 / 2073 U5 ]5 R1 }( Y, D9 z
5.6.3 思考＆作业 / 207
* z8 @! ^4 X! u7 H0 U5.7 金枝玉叶——探索“基数树”内部 / 2074 h9 F$ k7 l/ x5 }2 u9 T: i
5.7.1 应用 / 208
; l8 N2 O* }& B( F( ]6 O9 J: R3 h5.7.2 结构 / 210 |6 k) [$ ?* V/ ]2 j5 S
5.7.3 思考＆作业 / 213
+ E3 l7 q2 h8 ^. K0 C% Z4 x* B, t5.8 精益求精——LFU VS LRU / 213" \ s4 R8 I. {( \
5.8.1 Redis 对象的热度 / 2131 L* C# G0 k2 g I/ J1 P" @
5.8.2 LRU 模式 / 213# S0 \9 H# J% D( i/ ~' S7 Z( _
5.8.3 LFU 模式 / 214
! o& A5 q: w4 k6 F5.8.4 为什么 Redis 要缓存系统时间戳 / 2170 a% `" ~1 m3 i8 [3 q, J
5.8.5 Redis 为什么在获取 lruclock 时使用原子操作 / 2178 P5 {+ ]0 @6 F) `. \6 x1 a
5.8.6 如何打开 LFU 模式 / 218
* ?' h1 ?1 i. F% d Y8 j5.8.7 思考＆作业 / 218) y0 M' b9 B1 `! l- r$ t6 B
5.9 如履薄冰——懒惰删除的巨大牺牲 / 218% W1 G' k! `4 f4 H3 n+ N
5.9.1 懒惰删除的初实现不是异步线程 / 219
3 ~5 Q( P7 M, n5 U& `- R4 I% r) f5.9.2 异步线程方案其实也相当复杂 / 219
% X- [6 t& U. g* p5.9.3 异步删除的实现 / 221! k9 @" e. }$ f5 l- Z1 w
5.9.4 队列安全 / 224 java8.com3 g) h0 Y! W3 Z7 S
5.9.5 思考＆作业 / 225# s5 q2 W9 c4 L0 t. C
5.10 跋山涉水——深入字典遍历 / 225. {4 ]5 C" G# j7 k" \# J5 W) P
5.10.1 一边遍历一边修改 / 226& T/ }1 ]' W! R4 v/ D" V( B; v9 S
5.10.2 重复遍历的难题 / 227; Q5 h7 l4 m# c
5.10.3 迭代器的结构 / 2271 W( {0 i5 ?, Q% |
5.10.4 迭代过程 / 2298 q4 P3 \ D* |9 U# @/ |* ~- q
5.10.5 迭代器的选择 / 231
, m6 H O+ F6 ?5.10.6 思考＆作业 / 232
: d+ b$ e8 |8 [, b% O1 h# ^; T
2 _4 ^9 I* q! m9 m" t1 e' R
电子书
508 人阅读
|
27 人回复
|
2023-11-26
