在这篇文章中，我们将深入探讨一个看似基础却极具探讨价值的技术问题：如何在一个字符串中找出所有重复出现的字符并统计它们的次数。这不仅仅是算法面试中的常客，更是我们在处理文本分析、数据清洗和日志解析时经常遇到的实际需求。
给定一个字符串 s，我们的任务是找出所有出现次数超过一次的字符，并将每个字符及其计数作为一个列表打印出来。
示例场景：
> 输入： s = "geeksforgeeks"
> 输出： [‘e‘, 4], [‘g‘, 2], [‘k‘, 2], [‘s‘, 2]
> 说明： 字符 e, g, k, 和 s 出现了不止一次。它们的计数按照首次出现的顺序显示。
虽然这个问题看起来很简单，但作为经验丰富的开发者，我们知道“能运行”和“生产级”之间有着巨大的鸿沟。让我们从最基础的方法开始，一步步探索如何用 2026 年的现代开发理念来优雅地解决这个问题。
目录
- [基础篇] 使用排序法 – 适合内存受限场景
- [进阶篇] 哈希表法 – 通用的高性能方案
- [实战篇] 现代工程化视角与AI辅助开发 (2026)
基础篇：使用排序 – O(n*log(n)) 时间和 O(1) 空间
首先，让我们回顾一下经典的方法。排序法的核心思想是通过改变数据的物理存储顺序来降低统计的难度。当我们把字符排好序后，相同的字符就会“物以类聚”地挨在一起。这样，我们只需要遍历一次，就能轻松统计连续的重复项。
为什么选择这种方法？ 在某些极端的嵌入式环境或内存受限的系统中（例如某些IoT设备），我们无法承担额外的哈希表空间开销。这时，排序法就成为了最优解，因为它不需要额外的空间复杂度（取决于排序算法的实现）。
C++ 实现示例：
// C++ Code to print duplicate characters
// and their counts using Sorting
#include
using namespace std;
// Function to print duplicate characters with their count
void printDuplicates(string s) {
// 核心思路：先排序，将相同字符归类
sort(s.begin(), s.end());
// 遍历排序后的字符串
for (int i = 0; i < s.length();) {
int count = 1;
// 统计当前字符的连续出现次数
while (i + count 1) {
cout << "['" << s[i] << "', " << count << "], ";
}
// 跳过已统计的字符
i += count;
}
}
int main() {
string s = "geeksforgeeks";
printDuplicates(s);
return 0;
}
进阶篇：使用哈希 – O(n) 时间和 O(k) 空间
在现代应用开发中，时间通常是比空间更宝贵的资源。除非我们在处理TB级别的数据，否则使用哈希表通常是更优的选择。这种方法的时间复杂度是线性的 O(n)，意味着无论数据量多大，处理速度都极快。
让我们来看一个更健壮的 Python 实现，它不仅解决了问题，还考虑了代码的可读性和类型安全——这在 2026 年的代码审查中至关重要。
from collections import Counter
from typing import List, Tuple
def get_duplicates(s: str) -> List[Tuple[str, int]]:
"""
返回字符串中的重复字符及其计数。
使用 collections.Counter 保证 O(n) 的时间复杂度。
"""
if not s:
return []
# 计数是核心操作
counts = Counter(s)
# 使用列表推导式进行过滤，保持代码简洁
# 我们只关心 count > 1 的项
return [(char, count) for char, count in counts.items() if count > 1]
if __name__ == "__main__":
test_str = "geeksforgeeks"
result = get_duplicates(test_str)
print(result) # 输出: [(‘g‘, 2), (‘k‘, 2), (‘e‘, 4), (‘s‘, 2)]
实战篇：2026年的工程化视角与AI辅助开发
作为在这个行业摸爬滚打多年的开发者，我们知道代码写出来只是第一步。在 2026 年的今天，我们的开发范式已经发生了深刻的变化。让我们思考一下，如何用最新的技术理念来审视这个问题。
#### 1. Vibe Coding 与 AI 辅助工作流
现在的我们，很少会从零开始手写一个排序或哈希逻辑。当我们面对这样一个需求时，我们可能会打开 Cursor 或 Windsurf 这样的 AI 原生 IDE，直接在编辑器里输入我们的意图：“创建一个函数，统计字符串重复字符，要求保留首次出现顺序，并进行异常处理。”
Agentic AI (代理式 AI) 已经成为了我们的结对编程伙伴。它不仅能生成代码，还能帮助我们思考边界情况。比如，你有没有想过输入字符串是 None 或者 Unicode 表情符号 时会发生什么？
在我们的最近的一个微服务项目中，我们需要处理用户输入的海量日志。如果直接使用简单的排序或哈希，可能会因为内存溢出 (OOM) 导致服务崩溃。这时候，我们会利用 AI 辅助设计一个更复杂的流式处理架构，或者利用 Edge Computing (边缘计算) 将计算压力分散。
#### 2. 生产级代码：异常处理与健壮性
让我们把这个简单的算法升级为企业级的代码片段。在实际的生产环境中，我们不仅要处理逻辑，还要处理错误。
Java 企业级示例（包含异常处理和日志）：
import java.util.*;
import java.util.stream.Collectors;
public class StringUtil {
/**
* 分析字符串并返回重复字符的映射。
* 这是一个线程安全的方法。
*
* @param input 输入字符串，如果为 null 将返回空列表
* @return 包含字符和计数的 Map，仅包含重复项
*/
public static Map analyzeDuplicates(String input) {
// 防御性编程：处理空指针
if (input == null || input.isEmpty()) {
return Collections.emptyMap();
}
// 使用 Java 8+ Stream API 进行声明式编程
// 这种写法在 2026 年更符合函数式编程的潮流，便于并行处理
return input.chars()
.mapToObj(c -> (char) c)
.collect(Collectors.groupingBy(c -> c, Collectors.counting()))
.entrySet().stream()
.filter(entry -> entry.getValue() > 1)
.collect(Collectors.toMap(
Map.Entry::getKey,
entry -> entry.getValue().intValue()
));
}
public static void main(String[] args) {
String data = "programming";
Map duplicates = analyzeDuplicates(data);
// 输出: {r=2, g=2, m=2}
System.out.println("Duplicates found: " + duplicates);
// 测试边界情况：空字符串
System.out.println("Empty test: " + analyzeDuplicates(""));
}
}
#### 3. 性能优化与可观测性
当我们在设计高并发系统时，算法的选择至关重要。虽然哈希法是 O(n)，但其常数因子和哈希碰撞的开销在超大规模数据下可能成为瓶颈。这时候，我们可能会考虑更底层的优化，比如使用 Trie (前缀树) 结构（虽然对于单字符统计有点杀鸡用牛刀，但在多语言混合文本分析中很有用）。
更重要的是可观测性。在 2026 年，我们不会只打印结果到控制台。我们会将统计结果与 Prometheus 或 Grafana 集成，监控某些特定字符（如错误代码）出现的频率是否异常。
C# 现代异步示例（模拟真实应用场景）：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
public class DataProcessor
{
// 模拟一个从数据库或网络流异步获取数据的场景
public async Task<Dictionary> GetDuplicateStatsAsync(string dataSource)
{
return await Task.Run(() => {
if (string.IsNullOrWhiteSpace(dataSource))
return new Dictionary();
return dataSource.GroupBy(c => c)
.Where(g => g.Count() > 1)
.ToDictionary(g => g.Key, g => g.Count());
});
}
// 在实际应用中，我们可能会添加 Logging 和 Telemetry
// Logger.LogDebug("Processing duplicates for source: {Source}", dataSource);
}
#### 4. 安全左移 的考虑
你可能会问，一个简单的字符统计有什么安全风险？如果你处理的是用户输入，且这个统计结果被直接反馈给前端或用于数据库查询，那么注入攻击就是一个巨大的隐患。在 2026 年，我们在编写代码时必须时刻保持警惕，确保对输入进行严格的清洗和验证。
总结
从一个简单的字符串去重问题出发，我们探讨了从基础排序到现代哈希，再到结合 AI 辅助开发、流式处理和企业级异常处理的完整技术栈。技术在不断进化，但我们对代码质量、性能和安全的追求永远不变。
希望这篇文章不仅能帮你解决手头的算法题，更能启发你如何用未来的视角来思考当下的工程问题。让我们继续在技术的海洋中探索吧！