罗罗编程学习记录
本页内容 展开查看

04.6.1.5 字符串、集合与常用类型

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.6 C# 与 .NET / 04.6.1 C# 语言核心

04.6.1.5-001 string 不可变与 StringBuilder 取舍?

一句话结论

string 创建后不可修改,拼接/替换产生新实例;循环或大量拼接用 StringBuilder 维护可扩容字符缓冲,避免反复分配与复制。

概念解释

不可变保证字符串别名安全,但每次修改都分配新串并复制旧内容。StringBuilder 内部字符缓冲按需扩容,ToString() 时才生成最终字符串。

原理流程

  1. 少量拼接:直接 +/内插,编译器可优化相邻字面量。
  2. 循环/大文本:创建 StringBuilder 追加。
  3. 完成后 ToString() 输出字符串。

代码或图示

var sb = new StringBuilder();
foreach (var line in lines) sb.AppendLine(line);
string result = sb.ToString();

常见误区

  • 循环内 str += x:每次分配新串并复制,长循环 O(n²) 分配。
  • 所有场景都用 StringBuilder:少量拼接用字符串更简单,StringBuilder 有自身对象开销。

追问

  • StringBuilder 扩容策略?答:内部缓冲按需增长,具体容量增长规则以 BCL 实现为准;可预估容量减少重分配。
  • 字符串拼接在表达式树/EF 中注意?答:远程查询中的拼接需可翻译,本地拼接在客户端执行。

04.6.1.5-002 字符串内插、格式化与驻留?

一句话结论

$"..." 内插编译为格式化调用;字面量在程序集内驻留复用;string.Format/Join 用于模板化组合;比较时区分序号比较与文化比较。

概念解释

内插字符串可读且类型安全;重复字面量由驻留表复用。格式化占位符支持对齐与格式说明符;文化相关比较影响排序与大小写规则。

原理流程

  1. 内插表达式求值并格式化为字符串。
  2. 字面量驻留减少重复分配。
  3. 比较按指定 StringComparison 规则执行。

代码或图示

var msg = $"用户 {name} 共 {count} 条";
var eq = string.Equals(a, b, StringComparison.OrdinalIgnoreCase);

常见误区

  • 用 == 做文化敏感比较:== 按序号/默认规则,需要时显式指定比较类型。
  • 依赖驻留做身份判断:ReferenceEquals 不可靠,内容比较用 Equals。

追问

  • 内插字符串与 FormattableString?答:需要捕获格式参数做本地化/校验时用 FormattableString;普通内插直接生成结果串。
  • 字符串驻留何时发生?答:编译期字面量自动驻留;运行时字符串可 Intern 加入驻留表,注意驻留表生命周期。

04.6.1.5-003 字符串比较有哪些方式与坑?

一句话结论

比较分序号(按字符码位)与文化相关(按语言规则);常用 StringComparison.Ordinal/OrdinalIgnoreCase 做稳定比较,文化比较用于显示排序。

概念解释

序号比较确定性强、性能好,适合标识符、键、路径;文化比较尊重语言大小写与排序规则,适合用户可见文本。忽略大小写时必须显式指定,避免隐式文化差异。

原理流程

  1. 判断用途:标识/键用序号,显示/排序用文化。
  2. 显式传 StringComparison。
  3. 按规则比较字符序列。

代码或图示

bool same = path.Equals(other, StringComparison.OrdinalIgnoreCase);
var sorted = names.OrderBy(n => n, StringComparer.CurrentCulture);

常见误区

  • 跨平台依赖默认文化:不同区域排序/大小写规则不同,键比较应固定 Ordinal。
  • 用 ToLower() 再比较:额外分配且特殊字符(土耳其语 i)规则有误,应用忽略大小写比较。

追问

  • StringComparer 用途?答:作为 Dictionary/HashSet/排序的比较器,统一比较规则。
  • 包含/前缀判断?答:Contains/StartsWith/EndsWith 同样可传比较类型,避免默认文化行为。

04.6.1.5-004 List 扩容机制?

一句话结论

List<T> 内部数组缓冲,元素超容量时分配更大数组并复制旧元素;默认扩容按倍数增长(具体倍率以 BCL 版本为准),可 Capacity 预估减少重分配。

概念解释

List 提供动态长度,代价是扩容时的数组复制。已知元素规模时预设容量,避免多次复制;增删中间元素会移动后续元素。

原理流程

  1. 内部数组保存元素与 Count。
  2. Add 超容量:分配新数组,复制旧元素。
  3. 替换缓冲,继续添加。

代码或图示

var list = new List<Order>(capacity: expected);
list.AddRange(orders);

常见误区

  • 频繁在头部/中间插入:后续元素整体移动,大列表应评估链表或批量操作。
  • 反复 Add 触发多次扩容:预估 Capacity 或 AddRange 一次性填充。

追问

  • List 与数组互转?答:ToArray() 复制为数组;数组可构造 List 包装。
  • List 线程安全吗?答:非线程安全,多线程读写需加锁或用并发集合。

04.6.1.5-005 Dictionary<TKey,TValue> 底层要点?

一句话结论

Dictionary 用哈希表:键哈希定位桶,桶内条目链解决冲突;键需提供稳定相等与哈希码;负载过高时扩容重建表。

概念解释

查找平均 O(1),依赖 GetHashCode 分布与 Equals 相等。自定义键必须同时重写相等与哈希;可变对象作为键后修改会破坏查找。

原理流程

  1. 计算键哈希定位桶。
  2. 桶内按相等比较定位条目。
  3. 负载超阈值扩容,重新分布条目。

代码或图示

var map = new Dictionary<string, Order>(StringComparer.OrdinalIgnoreCase);
map[id] = order;
if (map.TryGetValue(id, out var found)) { }

常见误区

  • 用可变对象做键:字段修改后哈希变化,原条目查找不到。
  • 键类型未重写 GetHashCode/Equals:按引用比较,内容相同也视为不同键。

追问

  • 取值推荐 TryGetValue?答:避免 ContainsKey 后再索引器的两次查找;缺失时不抛异常。
  • 字典遍历顺序?答:不保证顺序,依赖顺序应使用有序结构或排序后快照。

04.6.1.5-006 HashSet 集合语义?

一句话结论

HashSet 基于哈希表保证元素唯一,提供交集/并集/差集运算;相等规则与 Dictionary 键一致,元素不应在集合内被修改。

概念解释

HashSet 用于去重与集合运算,不保留索引顺序。添加重复元素返回 false;集合运算直接修改集合并集/交集/差集。

原理流程

  1. 元素哈希定位桶。
  2. 相等判断是否已存在。
  3. 集合运算按成员规则组合。

代码或图示

var set = new HashSet<int> { 1, 2, 3 };
set.Add(2);                  // false
set.IntersectWith(other);

常见误区

  • 把 HashSet 当有序列表:无索引、无顺序保证。
  • 自定义元素未实现相等:按引用去重,内容重复仍保留。

追问

  • HashSet 与 Dictionary 关系?答:底层哈希表机制类似,HashSet 只存键;可用字典值为空实现映射。
  • 去重保留首次出现顺序?答:HashSet 不保证顺序,需要顺序用 LINQ Distinct 配合原序列。

04.6.1.5-007 Queue、Stack 与 LinkedList 适用场景?

一句话结论

Queue<T> 先进先出,Stack<T> 后进先出,LinkedList<T> 双向链表支持两端与节点级插入删除;按访问模式选择结构。

概念解释

队列用于任务排队、消息缓冲;栈用于回溯、嵌套解析;链表在频繁两端增删、节点级操作时有优势,但随机访问慢、节点开销大。

原理流程

  1. Queue 队尾入队、队首出队。
  2. Stack 栈顶压入/弹出。
  3. LinkedList 节点前后指针维护序列。

代码或图示

var q = new Queue<Job>();
q.Enqueue(job); var next = q.Dequeue();
var stack = new Stack<int>();

常见误区

  • 随机访问用 LinkedList:需从头遍历定位,O(n),随机访问选 List。
  • 用 Stack 做 FIFO 处理:顺序语义错误。

追问

  • Queue/Stack 内部实现?答:基于数组缓冲循环/栈顶指针,具体以 BCL 为准;容量按需增长。
  • 并发场景替代?答:多线程用 ConcurrentQueue/ConcurrentStack,见并发章节。

04.6.1.5-008 集合接口层次怎么划分?

一句话结论

IEnumerable<T> 可枚举,ICollection<T> 增删计数,IList<T> 按索引访问;IReadOnlyCollection/IReadOnlyList 暴露只读视图;接口按能力分层。

概念解释

接口层次描述最小能力:遍历用 IEnumerable,长度与修改用 ICollection,索引定位用 IList。只读接口防止外部修改内部集合,同时保留遍历能力。

原理流程

  1. 返回类型声明所需最小接口。
  2. 调用方按接口能力使用。
  3. 内部实现可替换具体集合。

代码或图示

public IReadOnlyList<Order> GetOrders() => _orders.AsReadOnly();

常见误区

  • 公共 API 直接暴露 List/内部可变集合:外部可绕过封装修改。
  • 只读接口暴露后仍返回内部可变实例:AsReadOnly 是包装,原集合变化会反映到视图。

追问

  • IEnumerable 与 ICollection 选择?答:只需遍历传 IEnumerable;需要 Count/Contains 传 ICollection。
  • 协变接口?答:IEnumerable<out T> 协变,只读集合可按基类型传递。

04.6.1.5-009 数组与集合如何互转?

一句话结论

ToArray/ToList 从集合生成数组/列表;数组可构造 List 或用 LINQ 包装;转换通常产生副本,注意内存与共享语义。

概念解释

数组是固定长度引用类型,List 是动态缓冲。互转时数据复制;需要动态长度用 List,需要定长缓冲用数组/Span。

原理流程

  1. 集合 ToArray() 复制元素到新数组。
  2. 数组 ToList() 包装为新 List。
  3. 副本与原集合独立修改。

代码或图示

Order[] arr = list.ToArray();
List<Order> again = arr.ToList();

常见误区

  • 以为转换共享底层数组:ToList/ToArray 产生副本,原集合修改不影响结果。
  • 大数组反复转换:增加分配与复制,按最终使用形态选择结构。

追问

  • 数组协变写入风险?答:引用类型数组可协变,写入不兼容元素运行时抛异常。
  • 集合判空与判空集合?答:区分 null 与空集合;公共方法应明确返回约定。

04.6.1.5-010 委托类型:Action、Func 与自定义 delegate?

一句话结论

Action 无返回值委托,Func 带返回值委托;自定义 delegate 用于命名签名、显式目标类型与协变逆变规则;委托封装方法引用。

概念解释

委托是类型安全的方法引用,可包装静态方法、实例方法、Lambda。泛型委托覆盖多数场景;自定义委托在需要文档化签名、特殊命名或互操作时使用。

原理流程

  1. 声明委托签名(返回 + 参数)。
  2. 实例绑定兼容方法/Lambda。
  3. 调用委托触发方法。

代码或图示

Func<int, int, int> add = (a, b) => a + b;
Action<string> log = Console.WriteLine;
delegate bool Validator(string input);

常见误区

  • 委托参数与方法签名不匹配:参数逆变、返回协变允许方向兼容,但类型必须可转换。
  • 以为委托直接存函数地址:委托实例持有目标对象与方法信息。

追问

  • 委托与函数指针区别?答:委托是托管类型支持多播与目标持有;函数指针轻量、无链,适用于互操作/高性能场景(语法以当前语言版本为准)。
  • 委托相等比较?答:按目标方法与目标对象比较;多播链相等规则不同。

04.6.1.5-011 多播委托与调用链?

一句话结论

委托可组合为多播,内部维护调用链;+/- 增减订阅者,调用时按顺序执行;链上方法返回值只取最后一个,异常会中断后续调用。

概念解释

多播委托是事件机制的基础。每个订阅者包装为链节点,调用时依次 Invoke。方法内部应自行捕获异常,避免中断其他订阅者。

原理流程

  1. 委托组合形成调用链。
  2. 调用时按订阅顺序执行。
  3. 返回值取链尾方法结果。

代码或图示

Action handler = A;
handler += B;
handler += C;
handler();   // A → B → C

常见误区

  • 链中方法抛异常未捕获:后续订阅者不再执行。
  • 期望每个方法返回值:多播委托只暴露最后返回值,需要结果应遍历调用列表。

追问

  • 如何遍历调用列表?答:GetInvocationList() 取各委托实例,逐个调用并分别处理异常/结果。
  • 委托链线程安全?答:增减订阅需注意竞态;事件声明用标准模式保护。

04.6.1.5-012 事件与公开委托的区别?

一句话结论

事件是基于委托的封装:外部只能 +=/-= 订阅,不能直接触发或清空;公开委托字段允许外部调用与覆盖,破坏封装。

概念解释

事件把「订阅」与「触发」权限分离:发布者内部 Invoke,订阅者只挂载处理器。标准事件声明用 event 关键字 + 委托类型,避免外部随意调用委托。

原理流程

  1. 发布者声明 event EventHandler。
  2. 订阅者 += 挂处理器,-= 取消。
  3. 发布者在内部状态变化时触发事件。

代码或图示

public event EventHandler<OrderArgs>? Paid;
protected virtual void OnPaid(OrderArgs e) => Paid?.Invoke(this, e);

常见误区

  • 公开委托字段代替事件:外部可 = null 清空或直接 Invoke。
  • 事件声明为公共字段:标准模式应使用事件封装与受保护触发方法。

追问

  • EventHandler 标准签名?答:object? sender, TEventArgs e;无数据事件用 EventHandler。
  • 事件与回调接口取舍?答:一对多通知用事件;单契约回调用委托/接口。

04.6.1.5-013 事件订阅泄漏怎么产生与避免?

一句话结论

长生命周期发布者持有短生命周期订阅者的委托,订阅者无法被回收;取消订阅、弱事件模式或明确生命周期管理可避免泄漏。

概念解释

委托持有订阅者方法与目标对象。发布者存活越久,未取消的订阅者越久被引用。常见于窗体、缓存、消息总线订阅未注销。

原理流程

  1. 订阅 += 把目标对象加入发布者调用链。
  2. 发布者长期存活,链持有订阅者引用。
  3. 订阅者失去其他引用仍无法 GC。

代码或图示

publisher.Paid += OnPaid;
// 释放前
publisher.Paid -= OnPaid;

常见误区

  • 只释放订阅者对象不取消订阅:发布者仍通过委托持有它。
  • Lambda 订阅无法 -=:匿名闭包无法用相同表达式取消,应保存委托实例。

追问

  • 弱事件模式解决什么?答:发布者弱引用订阅者,不阻止回收;实现复杂度与适用场景需评估。
  • 静态事件泄漏更严重?答:静态委托生命周期跟随程序域,取消订阅尤其重要。

04.6.1.5-014 集合元素相等与哈希规则?

一句话结论

集合查找依赖 Equals 与 GetHashCode:相等对象哈希必须一致;默认值类型按位比较,引用类型默认按引用,自定义类型需重写两者。

概念解释

哈希表先按哈希分桶,再按相等比较定位。哈希分布影响冲突率;相等规则不一致会导致 Dictionary/HashSet 行为异常。

原理流程

  1. 插入/查找计算键哈希。
  2. 桶内 Equals 比较。
  3. 相等则命中,否则新增。

代码或图示

public override bool Equals(object? obj) => obj is Product p && Sku == p.Sku;
public override int GetHashCode() => Sku.GetHashCode();

常见误区

  • 重写 Equals 不重写 GetHashCode:相等对象哈希不同,哈希表查找失败。
  • 哈希基于可变字段:修改后哈希变化,条目「丢失」。

追问

  • 如何使用自定义比较器?答:构造 Dictionary/HashSet 时传 IEqualityComparer<T>,不改类型自身实现。
  • 记录类型自动满足规则?答:record 自动生成一致的相等与哈希实现。

04.6.1.5-015 只读集合与不可变集合?

一句话结论

只读包装(ReadOnlyList/AsReadOnly)禁止通过包装修改,但底层可变集合变化会反映出来;不可变集合(System.Collections.Immutable)修改产生新实例,原集合不变。

概念解释

只读视图是访问控制层;不可变集合是数据本体设计。跨层共享、并发读取场景,不可变集合避免复制与同步问题。

原理流程

  1. 只读包装暴露受限接口。
  2. 底层集合仍可被持有引用修改。
  3. 不可变集合修改返回新结构,旧实例保持不变。

代码或图示

public IReadOnlyList<Order> PublicOrders => _orders.AsReadOnly();
var immutable = ImmutableArray.CreateRange(orders);

常见误区

  • 以为只读包装后底层不可变:包装不阻止持有内部引用的代码修改。
  • 大集合频繁用不可变集合:每次修改产生新结构,需按修改频率评估。

追问

  • 不可变集合适用场景?答:事件快照、缓存共享、无锁读取;写入频繁场景评估复制成本。
  • 命名空间与包?答:不可变集合在 System.Collections.Immutable 包,具体引用以目标框架为准。

04.6.1.5-016 常用值类型:DateTime、TimeSpan、Guid、decimal?

一句话结论

DateTime 日期时间,TimeSpan 时间间隔,Guid 全局唯一标识,decimal 高精度十进制数值;按用途选择,避免用 double 表示金额。

概念解释

DateTime 含种类(本地/UTC/未指定),跨时区处理需带时区信息;decimal 十进制精度适合货币;Guid 用于分布式标识,无顺序保证。

原理流程

  1. 按领域语义选类型:时间点 DateTimeOffset,间隔 TimeSpan,金额 decimal。
  2. 比较/运算按类型规则。
  3. 序列化保留种类与精度信息。

代码或图示

DateTimeOffset now = DateTimeOffset.UtcNow;
TimeSpan elapsed = stopwatch.Elapsed;
Guid id = Guid.NewGuid();
decimal price = 19.99m;

常见误区

  • 用 double/float 存金额:二进制浮点误差导致结算偏差。
  • 混用本地与 UTC DateTime:比较与存储前统一种类。

追问

  • DateTime 与 DateTimeOffset 区别?答:后者带偏移量,明确时间点与时区上下文;跨时区存储优先用后者。
  • Guid 有索引/顺序问题?答:随机 Guid 作为聚簇索引可能导致页分裂;有序 Guid/雪花标识方案依场景选择。

04.6.1.5-017 枚举器 IEnumerator 与 foreach 编译?

一句话结论

foreach 依赖 IEnumerable/GetEnumerator 返回枚举器:MoveNext() 推进、Current 取当前;编译器生成 using 释放枚举器资源。

概念解释

枚举器记录遍历位置;集合可实现枚举接口或提供同名方法。LINQ 延迟执行依赖枚举器按需产出元素;手动使用枚举器需释放资源。

原理流程

  1. 调用 GetEnumerator 取得枚举器。
  2. 循环 MoveNext 成功则读取 Current。
  3. 结束/dispose 释放枚举器。

代码或图示

using var e = list.GetEnumerator();
while (e.MoveNext()) { var item = e.Current; }

常见误区

  • 手动枚举器不释放:持有连接/流的枚举器资源悬挂。
  • 在枚举集合时修改集合:多数集合抛 InvalidOperationException,修改应在遍历后。

追问

  • 枚举器与迭代器方法?答:yield return 生成状态机枚举器,按需恢复产出元素。
  • 泛型与非泛型枚举器?答:IEnumerator<T> 强类型,避免装箱;非泛型 IEnumerator 为兼容旧代码。

04.6.1.5-018 集合线程安全概览?

一句话结论

普通 List/Dictionary/Queue 非线程安全;多线程并发访问需加锁或使用并发集合(ConcurrentDictionary/ConcurrentQueue 等),复合操作仍需一致性保护。

概念解释

并发集合内部用细粒度锁或无锁算法保证单操作安全;遍历、检查后执行、多步复合操作不自动加锁。具体锁策略与场景见并发章节。

原理流程

  1. 判断访问模式:单操作还是复合一致性。
  2. 单操作选并发集合。
  3. 复合操作用锁/信号量保证原子性。

代码或图示

var concurrent = new ConcurrentDictionary<string, Order>();
concurrent.TryAdd(id, order);

常见误区

  • 用并发集合就认为所有操作安全:复合步骤(先判断再写)仍可能竞态。
  • 大粒度锁包裹整个并发集合:退化为串行,损失并发收益。

追问

  • 并发集合迭代是否快照?答:遍历期间的可见性规则按具体集合实现;以 BCL 文档为准。
  • 生产者-消费者选什么?答:BlockingCollection 或 Channel,见并发与通道章节。