01.3.2.12 迭代器与其余行为型
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解
覆盖范围
- 迭代器模式的四个角色与遍历协议的本质
- Java 的
Iterable/Iterator关系与增强 for 语法糖 - Java fail-fast 机制与
ConcurrentModificationException - Go 手写
Next()闭包与 range 的适配方式 - Python 的
__iter__/__next__协议与生成器 - TypeScript 的
Symbol.iterator与生成器函数 - Rust 的
Iteratortrait 与惰性求值适配器链 - C# 的
IEnumerable<T>与yield return状态机 - PHP 的
Iterator接口与Generator协程 - 边遍历边修改导致迭代器失效的安全删除方式
- 中介者、备忘录、访问者三个模式的语言级落地与取舍
面试题索引
| 编号 | 题目 | 难度 | 状态 | 备注 |
|---|---|---|---|---|
| 01.3.2.12-001 | 迭代器模式解决什么问题?四个角色是什么? | 基础 | 已完成 | 意图与协议 |
| 01.3.2.12-002 | Java 的 Iterator 与 Iterable 是什么关系?增强 for 底层是什么? | 基础 | 已完成 | 语法糖与协议 |
| 01.3.2.12-003 | Java 的 fail-fast 机制是怎么工作的?什么情况抛异常? | 进阶 | 已完成 | modCount 与并发修改 |
| 01.3.2.12-004 | Go 怎么手写迭代器?range-over-func 是什么? | 进阶 | 已完成 | 闭包迭代与新特性 |
| 01.3.2.12-005 | Python 的 iter/next 协议与生成器是什么关系? | 基础 | 已完成 | 生成器即迭代器 |
| 01.3.2.12-006 | TypeScript 的 Symbol.iterator 协议与生成器函数怎么写? | 基础 | 已完成 | 可迭代协议 |
| 01.3.2.12-007 | Rust 的 Iterator trait 为什么是惰性求值? | 进阶 | 已完成 | 适配器链与零成本 |
| 01.3.2.12-008 | C# 的 IEnumerable<T> 与 yield return 是怎么工作的? | 进阶 | 已完成 | 编译器状态机 |
| 01.3.2.12-009 | PHP 的 Iterator 接口与 Generator 怎么写? | 进阶 | 已完成 | foreach 协议 |
| 01.3.2.12-010 | 边遍历边修改集合会发生什么?各语言怎么安全删除? | 进阶 | 已完成 | 失效与安全删除 |
| 01.3.2.12-011 | 中介者模式解决什么问题?它和观察者、外观的区别? | 进阶 | 已完成 | 中央协调与网状解耦 |
| 01.3.2.12-012 | 备忘录模式怎么实现撤销?和命令模式的 Undo 栈有什么区别? | 进阶 | 已完成 | 快照 vs 反向操作 |
| 01.3.2.12-013 | 访问者模式的双重分派是怎么工作的?开闭取舍在哪里? | 高级 | 已完成 | 双重分派与开闭倒置 |
| 01.3.2.12-014 | 访问者在现代语言里还必要吗?哪些 GoF 模式已退化为语言特性? | 高级 | 已完成 | 模式退化与语言特性 |
01.3.2.12-001 迭代器模式解决什么问题?四个角色是什么?
一句话结论
迭代器把「集合怎么存」和「怎么遍历」分开,调用方通过统一接口逐个取元素,不需要知道底层是数组、链表还是树;一个集合可以同时存在多个游标互不干扰。
概念解释
- 四个角色:集合(Aggregate,创建迭代器)、迭代器接口(
hasNext/next/remove)、具体迭代器(维护游标)、客户端(只依赖迭代器接口)。 - 本质:把遍历算法从集合类里抽出来,集合只负责存数据,迭代器负责「下一个是谁」。
- 收益:新增遍历方式(前序、后序、过滤)不改集合;集合内部结构调整不影响调用方。
原理流程
- 集合暴露
iterator()方法,返回一个新的迭代器实例。 - 迭代器内部持有当前游标与对集合的引用。
- 客户端循环调用
hasNext()与next(),游标前移。 - 多个迭代器实例各自维护游标,互相独立。
代码或图示
Aggregate ──iterator()──> Iterator
│ hasNext() 是否还有元素
│ next() 返回当前元素并前移
│ remove() 删除刚返回的元素(可选)
public interface Iterator<E> {
boolean hasNext();
E next();
default void remove() { throw new UnsupportedOperationException(); }
}
常见误区
- 认为迭代器只是
for循环的包装:它的价值在于把遍历策略抽象成对象,支持多种遍历与并发游标。 - 把迭代器和枚举(Enumeration)混为一谈:迭代器是现代统一协议,支持删除语义与泛型。
- 一个集合只允许一个迭代器:每个
iterator()调用返回新实例,多个游标可同时存在。
追问
- 迭代器和游标(Cursor)数据库的概念关系?答:思想同源,都是「位置 + 取下一个」,数据库游标在服务端维护位置,集合迭代器在内存中维护。
- 为什么要有
remove()而不是直接在集合上删?答:直接删会破坏迭代器内部游标,remove()让迭代器知道如何同步调整位置。
01.3.2.12-002 Java 的 Iterator 与 Iterable 是什么关系?增强 for 底层是什么?
一句话结论
Iterable 是「可被迭代」的标记接口,声明 iterator() 方法返回一个 Iterator;增强 for 语法糖只要求对象实现 Iterable,编译后展开成 iterator().hasNext()/next() 循环。
概念解释
Iterable<T>:有iterator()方法,是 for-each 的前提。Iterator<T>:真正的游标,有hasNext()/next()。- 数组没有实现
Iterable,但编译器对数组做了特殊处理,也能 for-each。
原理流程
- 编译器看到
for (E e : collection)。 - 如果
collection是数组,展开成索引循环。 - 如果是
Iterable,调用iterator()并展开成 while 循环。 var与泛型擦除不影响这个展开。
代码或图示
// 可迭代集合只需实现 Iterable
public class CardDeck implements Iterable<Card> {
private final List<Card> cards = new ArrayList<>();
@Override
public Iterator<Card> iterator() {
return cards.iterator();
}
}
// for-each
for (Card c : deck) {
System.out.println(c);
}
// 编译后等价于:
// Iterator<Card> it = deck.iterator();
// while (it.hasNext()) { Card c = it.next(); ... }
常见误区
- 以为实现
Iterator就能 for-each:必须实现Iterable,Iterator本身不是 for-each 的前提。 - 在 for-each 里调用
list.remove():会抛ConcurrentModificationException,应改用it.remove()。 - 以为
List有iterator()是它自己发明的:它来自Collection接口继承自Iterable。
追问
ListIterator和普通Iterator的区别?答:ListIterator支持双向遍历、set()替换当前元素、nextIndex(),只能由List生成。- 为什么
Iterable要返回新的Iterator而不是单例?答:多个游标独立遍历是迭代器的核心价值,单例会让两个循环互相干扰。
01.3.2.12-003 Java 的 fail-fast 机制是怎么工作的?什么情况抛异常?
一句话结论
Java 集合在迭代器内部维护一个期望的 modCount(集合结构修改次数),每次 next() 检查实际 modCount 是否等于期望值;不等就抛 ConcurrentModificationException,用于快速暴露多线程或单线程下的并发修改 bug。
概念解释
modCount:集合每次add/remove都会自增。- 迭代器创建时记录
expectedModCount。 next()开头做checkForComodification(),不一致即抛异常。- 这不是保证安全,而是「尽量早暴露」,不能作为同步手段。
原理流程
- 迭代器创建,记录
expectedModCount = modCount。 - 调用
it.next()前检查modCount == expectedModCount。 - 不一致立即抛异常,不继续遍历。
- 通过
it.remove()删除时,迭代器会同步更新expectedModCount,所以不抛异常。
代码或图示
List<String> list = new ArrayList<>(List.of("a", "b", "c"));
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String s = it.next();
if (s.equals("b")) {
list.remove(s); // 直接调用集合删除 → modCount 变了
}
}
// 下一次 it.next() 抛 ConcurrentModificationException
// 正确写法:用迭代器自己的 remove
it.remove();
常见误区
- 以为 fail-fast 是为了多线程安全:它是诊断机制,多线程下仍可能漏检,不能替代同步。
- 以为
it.remove()也会触发:它会同步更新expectedModCount,这是设计好的安全路径。 - 用
CopyOnWriteArrayList就万事大吉:它的迭代器是「快照」,不抛异常,但遍历的是旧数据,写操作对遍历不可见。
追问
- 为什么叫 fail-fast 而不是 fail-safe?答:它的目标是第一时间崩溃暴露 bug,而不是容忍错误继续跑。
ConcurrentHashMap的迭代器为什么不抛异常?答:它是弱一致(weakly consistent)迭代器,遍历反映的是迭代器创建时的状态,允许并发修改而不抛异常。
01.3.2.12-004 Go 怎么手写迭代器?range-over-func 是什么?
一句话结论
Go 没有内建的迭代器接口,惯用做法是返回一个「Next() 闭包」:调用方反复调用闭包,返回 (value, ok),ok=false 表示结束;标准 range 只能遍历切片、map、通道,不能直接作用于自定义集合。
概念解释
- 闭包迭代器:
func() (T, bool),每次调用取下一个。 - 这种模式需要调用方手写循环,不能直接
for v := range collection。 - range-over-func(迭代器函数作为 range 表达式)是 Go 较新引入的特性,允许
for v := range iterFn直接遍历自定义迭代器。
原理流程
- 集合暴露
Iter()方法,返回一个闭包。 - 闭包内部维护游标,每次调用返回下一个元素与是否结束。
- 调用方用
for配合Next()取值。 - 若使用 range-over-func,迭代器函数签名需满足语言规定的迭代器协议(具体签名与可用性以官方文档为准)。
代码或图示
package deck
type Card struct {
Suit string
Rank int
}
type Deck struct {
cards []Card
}
// Next 返回闭包迭代器:每次调用返回下一张牌和是否结束
func (d *Deck) Iter() func() (Card, bool) {
i := 0
return func() (Card, bool) {
if i >= len(d.cards) {
return Card{}, false
}
c := d.cards[i]
i++
return c, true
}
}
// 调用方
next := deck.Iter()
for {
c, ok := next()
if !ok {
break
}
_ = c
}
// range-over-func(待确认)
// 验证点:
// 1) 该特性在当前 Go 版本是否已稳定启用;
// 2) 迭代器函数签名(func(yield func(T) bool) 或等价形式);
// 3) 是否支持自定义集合直接 for v := range deck.Iter()。
// 用法示意:
// for c := range deck.Iter() { ... }
常见误区
- 以为 Go 有类似 Java
Iterator的内建接口:Go 的理念是「小接口 + 惯用写法」,不强制统一迭代协议。 - 闭包里忘记捕获游标:
i必须在闭包外定义,否则每次调用都从 0 开始。 - 把 range-over-func 当成已稳定特性直接写进项目:版本相关特性需确认当前工具链支持。
追问
- Go 的
range通道关闭后会怎样?答:通道关闭后 range 自动退出循环,这是通道作为迭代源的内置语义。 - 闭包迭代器为什么用
(T, bool)而不是抛异常?答:Go 错误处理惯例是多返回值,迭代结束是正常流程不是异常。
01.3.2.12-005 Python 的 iter/next 协议与生成器是什么关系?
一句话结论
Python 的迭代协议由 __iter__ 返回迭代器、__next__ 返回下一个元素(耗尽抛 StopIteration)构成;生成器函数(带 yield)就是语言语法自动生成的迭代器,两者协议完全兼容。
概念解释
- 可迭代对象:实现
__iter__,返回一个迭代器。 - 迭代器:实现
__next__,耗尽时抛StopIteration。 - 生成器:调用带
yield的函数时返回一个生成器对象,它自动实现了__iter__与__next__。 - 惰性:生成器只在请求时产出值,不一次性占内存。
原理流程
for x in obj调用iter(obj),即obj.__iter__()。- 每次循环调用
next(obj),即obj.__next__()。 - 抛
StopIteration时循环结束。 - 生成器函数在每个
yield处暂停,下次调用next()时从暂停处继续。
代码或图示
class Countdown:
def __init__(self, start: int) -> None:
self.current = start
def __iter__(self):
return self # 迭代器就是自己
def __next__(self) -> int:
if self.current <= 0:
raise StopIteration
self.current -= 1
return self.current + 1
# 生成器:同样的语义,语法更短
def countdown(n: int):
while n > 0:
yield n
n -= 1
for c in countdown(5):
print(c) # 5 4 3 2 1
常见误区
- 以为
__iter__必须返回self:可以返回一个独立的迭代器对象,支持多游标。 - 把生成器当列表用:生成器只能遍历一次,遍历完就耗尽;需要重复遍历要重新调用或转成 list。
- 在生成器里
return一个值:return后生成器结束,返回值不会被 for 捕获(要靠StopIteration.value或yield from)。
追问
iter(obj, sentinel)双参数形式是做什么的?答:把一个无参函数包成迭代器,直到返回值等于 sentinel,常用于读文件块。- 生成器和列表推导式的取舍?答:只遍历一次且数据量大用生成器(
(x for x in ...)),需要多次随机访问用列表。
01.3.2.12-006 TypeScript 的 Symbol.iterator 协议与生成器函数怎么写?
一句话结论
JS/TS 的可迭代协议由 Symbol.iterator 定义:对象有一个返回迭代器的方法,迭代器有 next() 返回 {value, done};生成器函数(function*)自动实现这个协议,是最简洁的迭代器写法。
概念解释
- 可迭代协议:
[Symbol.iterator]()返回迭代器。 - 迭代器协议:
next()返回{value, done}。 - 生成器函数:
function*声明,内部用yield,返回的生成器对象同时是可迭代对象和迭代器。 for...of只作用于可迭代对象,不作用于普通对象。
原理流程
for (const x of obj)调用obj[Symbol.iterator]()。- 每次循环调用返回的迭代器的
next()。 done === true时循环结束。- 生成器函数在
yield处暂停,下次next()时恢复。
代码或图示
class Range implements Iterable<number> {
constructor(private start: number, private end: number) {}
*[Symbol.iterator](): Generator<number> {
for (let i = this.start; i < this.end; i++) {
yield i;
}
}
}
// 直接 for...of
for (const n of new Range(1, 5)) {
console.log(n); // 1 2 3 4
}
// 生成器函数也能单独用
function* fib(limit: number) {
let [a, b] = [0, 1];
while (a < limit) {
yield a;
[a, b] = [b, a + b];
}
}
常见误区
- 以为
for...of能遍历普通对象:普通对象不可迭代,要用Object.keys()/Object.entries()或显式实现Symbol.iterator。 - 把生成器当数组用:生成器只能走一次,
[...gen]会把它展开成数组并耗尽它。 - 混淆
for...in和for...of:for...in遍历键名(含原型链),for...of遍历可迭代值。
追问
- 生成器的
yield*是做什么的?答:委托给另一个可迭代对象,逐个 yield 它的值,类似yield from。 - 迭代器和 observables 的区别?答:迭代器是「拉模式」(调用方要一个给一个),observable 是「推模式」(数据源主动推送)。
01.3.2.12-007 Rust 的 Iterator trait 为什么是惰性求值?
一句话结论
Rust 的 Iterator trait 只定义 next() 一个核心方法,map/filter/take 等适配器都返回新的迭代器类型、不立即执行;只有调用 collect()/for 循环时才真正拉取元素,这是零成本抽象——迭代器最终编译成手写循环。
概念解释
Iteratortrait:核心方法fn next(&mut self) -> Option<Self::Item>。- 适配器:
map、filter、take、enumerate、zip等,返回新迭代器。 - 惰性:适配器不消费元素,只是「装饰」迭代器,形成链式表达式。
- 消费者:
collect()、sum()、any()、for循环才真正驱动next()。
原理流程
- 从集合获得一个迭代器(
iter()/iter_mut()/into_iter())。 - 链式调用适配器,每个适配器包装前一个迭代器。
- 遇到消费者时,消费者反复调用
next(),沿链向上请求元素。 - 编译器把整个链优化成等价的手写循环,无运行时虚表开销。
代码或图示
fn main() {
let nums = vec![1, 2, 3, 4, 5];
let sum: i32 = nums
.iter()
.filter(|&&x| x % 2 == 0)
.map(|&x| x * 10)
.sum(); // 消费者:到此才真正执行
println!("{}", sum); // 60(20 + 40)
}
// 手写一个迭代器
struct Counter {
current: i32,
}
impl Iterator for Counter {
type Item = i32;
fn next(&mut self) -> Option<i32> {
if self.current < 5 {
self.current += 1;
Some(self.current)
} else {
None
}
}
}
常见误区
- 以为
map会立即执行:它只是构建迭代器链,不调用消费者就什么都不会发生。 - 忘记
iter()vsinto_iter():iter()产生借用,into_iter()取得所有权,类型不同。 - 在迭代器里写有副作用的闭包:惰性求值意味着副作用只在消费者驱动时发生,调用次数取决于消费者。
追问
Iterator为什么能零成本?答:每个适配器是一个具体类型,编译器 monomorphization 后内联展开,没有 trait 对象的虚表开销。- Rust 的迭代器和 C++ 的 STL 算法思路像吗?答:思路同源,都是「惰性/泛型算法 + 适配器」,Rust 把它做成了语言内建的 trait。
01.3.2.12-008 C# 的 IEnumerable<T> 与 yield return 是怎么工作的?
一句话结论
IEnumerable<T> 是「可被枚举」的接口,yield return 让编译器把方法改写成一个状态机:每次 MoveNext() 恢复到上次暂停处,产出一个元素,无需手写迭代器类。
概念解释
IEnumerable<T>:有GetEnumerator()返回IEnumerator<T>。IEnumerator<T>:有Current属性与MoveNext()方法。yield return:编译器自动生成状态机类,记录当前位置、局部变量、暂停点。- 延迟执行:
yield方法被调用时不执行,只有foreach或MoveNext()才驱动。
原理流程
- 调用
yield方法,返回一个枚举器对象,方法体尚未执行。 foreach开始时调用MoveNext(),执行到第一个yield return暂停。Current返回该元素。- 下次
MoveNext()从暂停处继续,直到方法结束返回false。
代码或图示
IEnumerable<int> EvenNumbers(int start, int count)
{
int produced = 0;
int current = start % 2 == 0 ? start : start + 1;
while (produced < count)
{
yield return current;
current += 2;
produced++;
}
}
// 调用:此时才真正执行
foreach (int n in EvenNumbers(1, 5))
{
Console.WriteLine(n); // 2 4 6 8 10
}
// 手写等价的迭代器(编译器自动生成的就是这种)
public interface IIterator<out T>
{
bool MoveNext();
T Current { get; }
}
常见误区
- 以为
yield方法调用时就执行:它只是构建状态机,延迟到foreach。 - 把
yield结果缓存成List后又抱怨失去惰性:ToList()会立即消费并耗尽。 - 在
yield方法里用try/finally:finally只在枚举器被完全耗尽或显式Dispose()时执行,提前break也会触发。
追问
yield break是什么?答:提前结束迭代,相当于MoveNext()返回false。- C# 的
IAsyncEnumerable<T>是什么?答:异步版本,配合await foreach,用于流式异步数据源,状态机由编译器生成。
01.3.2.12-009 PHP 的 Iterator 接口与 Generator 怎么写?
一句话结论
PHP 的 Iterator 接口要求实现 current()/key()/next()/rewind()/valid() 五个方法,foreach 原生支持;Generator 通过 yield 语法自动实现这个接口,是 PHP 里惰性迭代与协程的基础。
概念解释
Iterator接口:PHP 内建的迭代器协议,foreach检测到对象实现它就会按协议遍历。Generator:yield函数返回的对象,实现了Iterator与Countable等接口。- 惰性:生成器不一次性占内存,适合读大文件、分页查询。
原理流程
foreach遇到对象时先调rewind()。- 每次循环调
valid()判断是否有效。 - 有效则取
current()与key(),然后调next()。 yield函数在每个yield处暂停,下次next()时恢复。
代码或图示
<?php
// 1. 手动实现 Iterator
class NumberRange implements Iterator
{
private int $position = 0;
public function __construct(private int $start, private int $end) {}
public function rewind(): void { $this->position = $this->start; }
public function current(): int { return $this->position; }
public function key(): int { return $this->position; }
public function next(): void { $this->position++; }
public function valid(): bool { return $this->position <= $this->end; }
}
foreach (new NumberRange(1, 5) as $n) {
echo $n; // 12345
}
<?php
// 2. Generator:同样的语义,语法更短
function readLines(string $file): Generator
{
$handle = fopen($file, 'r');
while (($line = fgets($handle)) !== false) {
yield $line;
}
fclose($handle);
}
foreach (readLines('/var/log/app.log') as $line) {
// 逐行处理,不一次性加载整个文件
}
常见误区
- 以为
foreach能遍历任意对象:只有实现Iterator或IteratorAggregate的对象才能被foreach。 - 把 Generator 当数组:Generator 只能走一次,且不支持随机访问与
count()(除非额外实现)。 - 在 Generator 里
return值:return会结束生成器,返回值通过getReturn()获取,不被yield产出。
追问
yield from是做什么的?答:委托遍历另一个可迭代对象或生成器,逐个产出它的值。- Generator 在 PHP 里怎么当协程用?答:结合
send()与yield接收外部值,实现协作式调度,Swoole/衍生库常用这种模式。
01.3.2.12-010 边遍历边修改集合会发生什么?各语言怎么安全删除?
一句话结论
边遍历边直接修改集合结构会让迭代器内部游标与集合状态不一致:Java 抛 ConcurrentModificationException,C++ 迭代器失效,Python/JS 表现为跳过元素或提前结束;安全做法是用迭代器自带的删除方法、或先收集待删除项再统一删。
概念解释
- Java:fail-fast 抛异常,安全路径是
it.remove()。 - Python:列表遍历中
remove会跳过元素,推荐倒序遍历或推导式重建。 - TypeScript/JS:
for...of中splice会跳过元素。 - C#:
foreach中修改集合直接抛InvalidOperationException。 - Rust:迭代器借用规则在编译期禁止遍历时修改集合。
原理流程
- 遍历开始,迭代器记录当前状态。
- 外部直接
add/remove,集合结构变化。 - 迭代器再
next()时发现状态不一致,要么抛异常,要么游标错位。 - 安全路径:先标记待删除项,遍历结束后统一过滤重建;或用迭代器提供的删除方法。
代码或图示
// Java:安全删除
Iterator<String> it = list.iterator();
while (it.hasNext()) {
if (it.next().startsWith("tmp")) {
it.remove(); // 安全:迭代器同步更新 modCount
}
}
# Python:不安全,会跳过元素
for x in items:
if x.startswith("tmp"):
items.remove(x) # 下一个元素被跳过
# 安全做法:列表推导式重建
items = [x for x in items if not x.startswith("tmp")]
// TypeScript:先收集再过滤
const toRemove = new Set<string>();
for (const id of ids) {
if (id.startsWith("tmp")) toRemove.add(id);
}
const filtered = ids.filter((x) => !toRemove.has(x));
// Rust:编译期就禁止
// let mut v = vec![1, 2, 3];
// for x in v.iter() {
// v.push(*x); // 编译错误:v 已被不可变借用
// }
常见误区
- 以为用
for循环就安全:Java 的 for-each 底层还是迭代器,一样会 fail-fast。 - 在 C#
foreach里RemoveAt:直接抛InvalidOperationException,应转成 for 倒序索引。 - 用并发集合就忽略修改语义:
CopyOnWriteArrayList的遍历是快照,删除操作不会反映到正在进行的遍历上。
追问
- 为什么倒序遍历能安全删除?答:从后往前删,前面的索引不受影响,不会错位。
- Rust 怎么实现「遍历时收集待删除项」?答:先
iter().filter().collect()收集,再赋值回去,借用规则天然分开了读与写。
01.3.2.12-011 中介者模式解决什么问题?它和观察者、外观的区别?
一句话结论
中介者把多个同事对象之间的网状引用收敛到一个中央协调对象,同事之间只认识中介者;它和观察者的区别是「方向」不同(中介者主动转发,观察者被动订阅),和外观的区别是「对内对外」不同(中介者解耦内部同事互调,外观简化对外入口)。
概念解释
- 角色:中介者接口、具体中介者、同事对象。
- 网状引用:A 知道 B、C、D,B 知道 A、C、D……维护成本高。
- 中介者:A 只认识中介者,由中介者决定通知谁。
- 适用:聊天室、航班调度、GUI 控件联动、多表单组件联动。
原理流程
- 梳理同事对象之间的调用关系,画出网状图。
- 抽取公共交互为中介者接口。
- 同事对象持有中介者引用,事件发生时
mediator.notify(event)。 - 中介者根据事件决定转发给哪些同事。
代码或图示
// 聊天室:成员不直接互发消息,都交给聊天室
abstract class User {
public abstract void send(String msg);
public abstract void receive(String msg);
}
class ChatRoom {
public void showMessage(User user, String msg) {
System.out.println(user.name + ": " + msg);
}
}
无中介者: A ↔ B ↔ C ↔ D(网状,N 个对象 N*(N-1) 条引用)
有中介者: A ──> Mediator <── B
C ──> Mediator <── D(每个对象只认识中介者)
常见误区
- 把中介者写成上帝类:中介者只协调交互,不承担同事自身的业务逻辑。
- 同事仍保留对其他同事的直接引用:解耦不彻底,等于穿了中介者的外衣。
- 把所有联动都塞进一个中介者:联动规则多了应拆成多个职责单一的中介者。
追问
- 中介者和事件总线(观察者)怎么区分?答:事件总线是「发布者不知道订阅者是谁」,中介者是「同事知道中介者、中介者知道同事」;前者更解耦,后者更可控。
- 前端状态管理(如 Redux)是中介者吗?答:是,Store 就是中央协调者,组件 dispatch action,Store 决定如何更新状态并通知订阅组件。
01.3.2.12-012 备忘录模式怎么实现撤销?和命令模式的 Undo 栈有什么区别?
一句话结论
备忘录在不暴露对象内部结构的前提下保存状态快照,回滚时直接恢复整个快照;命令模式的 Undo 栈记录操作序列,回滚时执行反向操作。前者是「存状态」,后者是「存操作」,内存开销与复杂度特征不同。
概念解释
- 三个角色:发起人(Originator,创建/恢复备忘录)、备忘录(Memento,不可变快照)、负责人(Caretaker,保存快照栈)。
- 命令 Undo:每个命令对象自带
undo(),栈里存的是命令而不是状态。 - 备忘录适合「状态恢复代价小、操作历史复杂」的场景;命令 Undo 适合「操作可逆、状态大」的场景。
原理流程
- 操作前,发起人
createMemento()保存当前状态。 - 负责人把备忘录压入栈。
- 撤销时,负责人弹出备忘录,交回发起人
restore(memento)。 - 命令模式则是把每个变更命令压栈,撤销时调用
command.undo()。
代码或图示
// 备忘录:保存编辑器状态
class Editor {
private String text = "";
public Memento save() { return new Memento(text); }
public void restore(Memento m) { this.text = m.text; }
}
class Memento {
public final String text;
public Memento(String text) { this.text = text; }
}
class History {
private final Deque<Memento> stack = new ArrayDeque<>();
public void push(Memento m) { stack.push(m); }
public Memento pop() { return stack.pop(); }
}
备忘录:栈里存 [状态快照1, 状态快照2, 状态快照3]
撤销 = 弹出快照,整体覆盖
命令: 栈里存 [命令1(undo), 命令2(undo), 命令3(undo)]
撤销 = 弹出命令,执行它的 undo()
常见误区
- 备忘录里共享可变引用:快照保存了引用,后续原对象变了快照也跟着变,必须深拷贝或只存不可变数据。
- 无限制保存快照:大对象快照会让内存爆炸,需要设置历史上限或用基线 + 增量。
- 以为备忘录和命令二选一:实际编辑器常两者结合——命令栈记录操作,关键节点用备忘录做基线检查点。
追问
- 大对象怎么做高效快照?答:只存差异(diff),定期全量基线 + 增量,恢复时回放增量。
- Git 的 commit 是备忘录还是命令?答:是备忘录——每次 commit 保存整个文件树的快照,checkout 是恢复快照。
01.3.2.12-013 访问者模式的双重分派是怎么工作的?开闭取舍在哪里?
一句话结论
访问者通过两次方法调用完成分派:元素 accept(visitor) 先把自身类型传给 visitor,visitor 再调用对应 visit(元素类型) 方法;它对「新增操作」开放(加 visitor 类即可),但对「新增元素类型」封闭(必须改所有 visitor 接口),是开闭原则的「有方向取舍」。
概念解释
- 双重分派:第一次分派按元素类型(
this的类型),第二次按 visitor 的visit重载。 - 元素结构稳定:元素类型集合不常变,操作频繁新增。
- 开闭倒置:经典开闭是「对扩展开放、对修改封闭」,访问者选择了「操作可扩展、元素不可扩展」。
原理流程
- 元素实现
accept(Visitor v),内部调v.visit(this)。 this的编译期类型决定调用哪个visit重载。- 新增操作:实现一个新 Visitor 类,所有元素类型都不用改。
- 新增元素类型:必须在 Visitor 接口加一个
visit(新元素),所有现有 Visitor 都要改。
代码或图示
interface Shape {
void accept(Visitor v);
}
class Circle implements Shape {
public void accept(Visitor v) { v.visit(this); } // this 是 Circle
}
class Square implements Shape {
public void accept(Visitor v) { v.visit(this); } // this 是 Square
}
interface Visitor {
void visit(Circle c);
void visit(Square s);
}
class XmlExportVisitor implements Visitor {
public void visit(Circle c) { /* 导出圆的 XML */ }
public void visit(Square s) { /* 导出方的 XML */ }
}
常见误区
- 元素类型频繁变化还用访问者:加一个元素要改所有 visitor 接口和实现,代价远大于直接 if/else。
- 访问者突破元素封装:
visit应通过元素暴露的只读接口操作,不直接拿私有字段。 - 以为访问者是「万能解耦」:它的解耦是有方向的,选错方向反而更难维护。
追问
- 双重分派和普通单分派的区别?答:普通 OOP 只按接收者类型分派(一次),访问者结合元素类型与 visitor 类型两次分派。
- 编译器 AST 为什么常用访问者?答:AST 节点类型(类、方法、表达式)相对稳定,而操作(类型检查、代码生成、格式化)频繁新增,正好匹配访问者的方向。
01.3.2.12-014 访问者在现代语言里还必要吗?哪些 GoF 模式已退化为语言特性?
一句话结论
在有模式匹配(pattern matching)的语言里,访问者的大量场景已被语言特性吸收:Rust 的 match、TypeScript 的类型守卫、C# 的 switch 类型模式、Scala 的模式匹配都能更简洁地完成「按类型分发操作」;GoF 23 个模式中,迭代器、单例、命令、状态、装饰器等都已被语言特性大幅替代。
概念解释
- 模式匹配:语言级的「按类型/形状分发」,不需要写 visitor 类层次。
- 退化模式:迭代器(for-each/generator)、单例(模块/枚举/
object)、命令(一等函数/lambda)、状态(enum + 状态机库)、装饰器(注解/闭包/@decorator)。 - 仍有价值的模式:策略、观察者、中介者、备忘录、工厂、代理——这些是「架构决策」,不是语法糖能替代的。
原理流程
- 先判断问题是「语法层面」还是「架构层面」。
- 语法层面的遍历、单例、简单包装,优先用语言特性。
- 架构层面的职责拆分、解耦、扩展点,仍需要显式模式。
- 访问者在「元素类型也频繁变化」的项目里基本被模式匹配替代。
代码或图示
// Rust:模式匹配替代访问者
enum Shape {
Circle(f64),
Square(f64),
}
fn area(shape: &Shape) -> f64 {
match shape {
Shape::Circle(r) => std::f64::consts::PI * r * r,
Shape::Square(s) => s * s,
}
}
// TypeScript:类型守卫 + switch 替代 visitor
type Shape = { kind: "circle"; r: number } | { kind: "square"; s: number };
function area(shape: Shape): number {
switch (shape.kind) {
case "circle": return Math.PI * shape.r * shape.r;
case "square": return shape.s * shape.s;
}
}
退化清单:
迭代器 → for-each / generator / Iterator trait
单例 → 模块 / enum / object / OnceLock
命令 → 一等函数 / lambda / delegate
状态 → enum + 状态机 / match
装饰器 → 注解 / 闭包 / @decorator
访问者 → 模式匹配 / sum type
常见误区
- 以为「语言特性替代了模式」等于「模式没用了」:替代的是机械实现,模式的「意图」仍然是设计词汇。
- 在没有模式匹配的语言(Java 8/Go)里硬上访问者:Java 17+ 的 sealed class + pattern matching 已大幅简化,Go 则用接口 + type switch。
- 用模式匹配就忽视了「开闭方向」:match 对「新增元素」封闭(要加分支),对「新增操作」开放(新写一个 match 函数)——和访问者方向相同,只是语法更轻。
追问
- Go 没有模式匹配,访问者还有价值吗?答:Go 用接口 +
type switch达到类似效果,但新增类型要改所有 switch;如果元素类型稳定,type switch 比 visitor 类层次更轻。 - 为什么面试还在考这些「已退化」的模式?答:考察的是「什么时候该用、什么时候语言特性就够了」,而不是手写类层次。
跨语言差异对照
| 语言 | 惯用实现 | 差异要点 |
|---|---|---|
| Java | Iterable/Iterator + fail-fast |
for-each 语法糖;modCount 并发修改检测;ListIterator 双向 |
| Go | 手写 Next() 闭包;range 原生只支持切片/map/通道 |
无内建迭代器接口;range-over-func 为较新特性(待确认) |
| Python | __iter__/__next__ 协议;生成器函数 |
生成器是语言级迭代器;惰性;只能走一次 |
| TypeScript/JS | Symbol.iterator 协议;function* 生成器 |
协议由 symbol 定义;可迭代对象无处不在;for...of |
| Rust | Iterator trait;适配器链 + 消费者 |
惰性求值;零成本抽象;借用规则禁止遍历时修改 |
| C#/.NET | IEnumerable<T>;yield return |
编译器生成状态机;延迟执行;IAsyncEnumerable 异步版 |
| PHP | Iterator 接口;Generator + yield |
foreach 原生支持;Generator 是协程雏形;只能走一次 |
跨语言差异
- Java 是唯一把「并发修改检测」做成迭代器内建行为的语言(fail-fast),其他语言要么靠借用规则(Rust),要么靠约定(Python/JS)。
- Go 没有内建迭代器协议,惯用闭包
Next(),这是「接口最小化」哲学的体现;range-over-func 若稳定将改变这一格局,需以实际工具链版本验证。 - Rust 把迭代器做成 trait + 适配器链,编译期优化成手写循环,是「零成本抽象」的代表。
- Python、TypeScript、PHP 都把生成器(
yield)作为迭代器的语法糖,惰性求值是共同特征。 - C# 的
yield是编译器状态机,与IAsyncEnumerable一脉相承,是 .NET 异步流式处理的基础。 - 访问者在现代语言里普遍被模式匹配、sealed class、sum type 替代,手写 visitor 类层次越来越少。
待整理清单
- [ ] 验证 Go range-over-func 在当前工具链的稳定状态与签名
- [ ] 补充 C++ STL 迭代器失效规则与 Rust 借用规则的对照
- [ ] 补充各语言迭代器在大数据量下的性能基准(本机实测后填入)
- [ ] 补充 RxJS / Observables 与迭代器的拉推模式对比