Java 字符串相同字符处理：高效读取与统计完全指南236

好的，作为一名专业的程序员，我将为您撰写一篇关于在 Java 中处理相同字符的优质文章，涵盖从基础到高级的多种方法，并提供详细的代码示例和解释。
---

在日常的软件开发中，我们经常会遇到需要处理字符串中相同字符的场景。无论是进行数据压缩（如行程编码RLE）、文本分析、日志处理、数据清洗还是用户输入验证，有效地“读取”或“识别”出字符串中的相同字符都是一项核心任务。本文将深入探讨在 Java 中如何高效地实现这一目标，涵盖统计所有相同字符的出现次数、查找并分组连续的相同字符，以及利用现代 Java 特性（如Stream API）和正则表达式来解决这些问题。

“读取相同字符”这个需求本身可能包含多种解释，主要可以分为以下两种核心场景：

统计所有相同字符的出现次数： 例如，给定字符串 "banana"，我们需要知道 'b' 出现了 1 次，'a' 出现了 3 次，'n' 出现了 2 次。
查找并分组连续的相同字符： 例如，给定字符串 "AAABBCDDDE"，我们需要识别出 'A' 连续出现 3 次，'B' 连续出现 2 次，'C' 连续出现 1 次，'D' 连续出现 3 次，'E' 连续出现 1 次。

接下来，我们将针对这两种场景，分别介绍多种实现方法。

1. 统计所有相同字符的出现次数

统计字符串中每个字符的出现频率是字符处理的常见任务。Java 提供了多种数据结构和方法来实现这一目标。

1.1 基础迭代法：使用 HashMap

最直观且常用的方法是遍历字符串，并使用 `HashMap` 来存储每个字符及其对应的出现次数。

import ;
import ;
public class CharFrequencyCounter {
/
* 统计字符串中每个字符的出现次数。
*
* @param text 待统计的字符串
* @return 一个Map，键为字符，值为该字符出现的次数
*/
public static Map<Character, Integer> countAllChars(String text) {
if (text == null || ()) {
return new HashMap<>(); // 返回空Map
}
Map<Character, Integer> charCounts = new HashMap<>();
// 将字符串转换为字符数组进行遍历，效率更高，或者直接使用 (i)
for (char c : ()) {
(c, (c, 0) + 1);
}
return charCounts;
}
public static void main(String[] args) {
String s1 = "banana";
String s2 = "programming";
String s3 = "aabbcdeff";
String s4 = ""; // 空字符串
String s5 = null; // null字符串
("Counts for " + s1 + ": " + countAllChars(s1));
("Counts for " + s2 + ": " + countAllChars(s2));
("Counts for " + s3 + ": " + countAllChars(s3));
("Counts for " + s4 + ": " + countAllChars(s4));
("Counts for " + s5 + ": " + countAllChars(s5));
}
}

解释：

`getOrDefault(key, defaultValue)` 方法在 Java 8 中引入，如果 Map 中存在 `key`，则返回其对应的值；否则返回 `defaultValue`。这大大简化了“如果键不存在就初始化为0，否则递增”的逻辑。
时间复杂度为 O(N)，其中 N 是字符串的长度，因为我们需要遍历字符串一次。
空间复杂度为 O(K)，其中 K 是字符串中不同字符的数量。在最坏情况下，K 可以等于 N（所有字符都不同）。

1.2 Java 8 Stream API：更简洁的写法

Java 8 引入的 Stream API 提供了功能强大且表达力强的处理集合数据的方式。对于统计字符频率，Stream API 可以用一行代码实现。

import ;
import ;
import ;
public class CharFrequencyStream {
/
* 使用 Java 8 Stream API 统计字符串中每个字符的出现次数。
*
* @param text 待统计的字符串
* @return 一个Map，键为字符，值为该字符出现的次数
*/
public static Map<Character, Long> countAllCharsWithStream(String text) {
if (text == null || ()) {
return (); // Java 9+ 返回空Map
}
return () // 获取 IntStream，其中每个 int 是字符的 ASCII/Unicode 值
.mapToObj(c -> (char) c) // 将 int 转换为 Character 对象
.collect(((), ()));
}
public static void main(String[] args) {
String s1 = "banana";
String s2 = "programming";
String s3 = "aabbcdeff";
("Stream Counts for " + s1 + ": " + countAllCharsWithStream(s1));
("Stream Counts for " + s2 + ": " + countAllCharsWithStream(s2));
("Stream Counts for " + s3 + ": " + countAllCharsWithStream(s3));
}
}

解释：

`()`：将字符串转换为一个 `IntStream`，其中每个元素是字符的 Unicode 值。
`mapToObj(c -> (char) c)`：将 `IntStream` 中的每个 `int` 值转换为 `Character` 对象流。
`collect(((), ()))`：这是一个强大的收集器。

`groupingBy(())`：根据元素自身进行分组（即字符本身作为键）。
`()`：对每个分组中的元素进行计数，作为值。


返回的 Map 值类型是 `Long`，因为 `()` 返回 `long` 类型。

2. 查找并分组连续的相同字符

识别字符串中连续出现的相同字符及其数量，是实现行程编码（Run-Length Encoding, RLE）等算法的基础。

2.1 基础迭代法：单指针遍历

最直接的方法是使用一个循环和几个变量来跟踪当前字符和它的连续出现次数。

import ;
import ;
import ;
import ;
public class ConsecutiveCharGrouper {
/
* 查找字符串中连续相同的字符及其出现次数。
*
* @param text 待处理的字符串
* @return 一个List，每个元素是一个，表示一个连续字符及其次数
*/
public static List<<Character, Integer>> findConsecutiveChars(String text) {
List<<Character, Integer>> result = new ArrayList<>();
if (text == null || ()) {
return result;
}
char[] chars = ();
int n = ;
int i = 0; // 当前遍历到的字符索引
while (i < n) {
char currentChar = chars[i];
int count = 0;
int j = i; // 用于统计当前字符连续出现次数的辅助索引
// 统计当前字符连续出现的次数
while (j < n && chars[j] == currentChar) {
count++;
j++;
}
// 将结果添加到列表中
(new <>(currentChar, count));
// 更新主索引，跳过已处理的连续字符块
i = j;
}
return result;
}
public static void main(String[] args) {
String s1 = "AAABBCDDDE";
String s2 = "ABCDE";
String s3 = "AAAAA";
String s4 = "A";
String s5 = "";
("Consecutive for " + s1 + ": " + findConsecutiveChars(s1));
("Consecutive for " + s2 + ": " + findConsecutiveChars(s2));
("Consecutive for " + s3 + ": " + findConsecutiveChars(s3));
("Consecutive for " + s4 + ": " + findConsecutiveChars(s4));
("Consecutive for " + s5 + ": " + findConsecutiveChars(s5));
}
}

解释：

使用两个指针 `i` 和 `j`。`i` 负责遍历整个字符串，每次循环开始时指向一个新的字符块的起始位置。`j` 则从 `i` 开始向后扫描，直到遇到与 `chars[i]` 不同的字符或到达字符串末尾。
`while (j < n && chars[j] == currentChar)` 循环负责统计当前字符 `currentChar` 连续出现的次数。
当内部循环结束时，`count` 就是 `currentChar` 的连续出现次数，`j` 指向了下一个不同字符的起始位置。
将 `(currentChar, count)` 作为一个 `` 添加到结果列表中。
最后，将 `i` 更新为 `j`，跳过已处理的字符块，继续下一次外部循环。
时间复杂度为 O(N)，因为每个字符最多被访问两次（由 `i` 和 `j` 各访问一次）。
空间复杂度为 O(M)，其中 M 是连续字符块的数量。

2.2 使用正则表达式

正则表达式提供了一种强大且简洁的方式来匹配字符串中的模式。我们可以使用反向引用来查找连续相同的字符。

import ;
import ;
import ;
import ;
import ;
import ;
public class ConsecutiveCharRegex {
/
* 使用正则表达式查找字符串中连续相同的字符及其出现次数。
*
* @param text 待处理的字符串
* @return 一个List，每个元素是一个，表示一个连续字符及其次数
*/
public static List<<Character, Integer>> findConsecutiveCharsWithRegex(String text) {
List<<Character, Integer>> result = new ArrayList<>();
if (text == null || ()) {
return result;
}
// 正则表达式解释：
// (.) - 捕获任何字符（除了行终止符）到第1组
// \1+ - 匹配第1组捕获到的内容，一次或多次
// 整个表达式 (.\\1+) 匹配一个或多个连续相同的字符
Pattern pattern = ("(.)\\1*"); // 或者 (.\\1+) 如果不希望匹配单个字符
// (.\\1*) 可以匹配 'A' (A出现1次)
// (.\\1+) 可以匹配 'AA' (A出现2次), 但不会匹配 'A' (A出现1次)
// 为了匹配所有连续块，包括单个字符，使用 (.\\1*) 更合适
Matcher matcher = (text);
while (()) {
String match = (0); // 整个匹配到的字符串，如 "AAA"
char character = (0); // 连续字符，如 'A'
int count = (); // 出现次数，如 3
(new <>(character, count));
}
return result;
}
public static void main(String[] args) {
String s1 = "AAABBCDDDE";
String s2 = "ABCDE";
String s3 = "AAAAA";
String s4 = "A";
String s5 = "";
("Regex Consecutive for " + s1 + ": " + findConsecutiveCharsWithRegex(s1));
("Regex Consecutive for " + s2 + ": " + findConsecutiveCharsWithRegex(s2));
("Regex Consecutive for " + s3 + ": " + findConsecutiveCharsWithRegex(s3));
("Regex Consecutive for " + s4 + ": " + findConsecutiveCharsWithRegex(s4));
("Regex Consecutive for " + s5 + ": " + findConsecutiveCharsWithRegex(s5));
}
}

解释：

`("(.)\\1*")`：

`(.)`：这是一个捕获组，它会匹配任何单个字符（除了行终止符）并将其"捕获"下来。这个被捕获的字符可以在后面通过反向引用 `\1` 来再次引用。
`\\1*`：`\1` 表示引用第一个捕获组匹配到的内容，`*` 表示这个内容可以出现零次或多次。结合起来，`\1*` 就会匹配与第一个字符相同的零个或多个连续字符。
所以，`"(.)\\1*"` 整体匹配的是一个字符及其后面所有与它连续相同的字符。例如，对于 "AAA"，`(.)` 捕获 'A'，`\1*` 匹配随后的 'AA'。对于 "B"，`(.)` 捕获 'B'，`\1*` 匹配零次。


`()`：在输入字符串中查找下一个与模式匹配的子序列。
`(0)`：返回整个匹配到的字符串（例如 "AAA"）。
`(0)`：获取匹配到的连续字符。
`()`：获取该字符的连续出现次数。
正则表达式方法通常更简洁，但对于非常大的字符串，其性能可能不如手写的迭代法。

2.3 Stream API 处理连续字符的挑战与混合方案

虽然 Stream API 在聚合操作（如 `groupingBy`）方面表现出色，但直接用纯 Stream API 来处理“连续”这种带有状态和顺序依赖的问题会比较复杂，因为它本质上是无状态的。`groupingBy` 通常会根据一个键将所有满足条件的元素分组，而不管它们在原始序列中的位置。

因此，对于查找连续相同字符，纯 Stream API 的解决方案通常不如迭代法或正则表达式直观和高效。我们可能会需要自定义 `Collector`，或者在 Stream 管道中引入外部状态（这与 Stream 的设计理念相悖），或者结合 `` 来模拟索引，但代码复杂性会显著增加。

通常，在这种情况下，推荐的做法是：

如果需要简洁，并且对性能要求不是极致，可以使用正则表达式。
如果对性能和控制力要求高，或者字符串非常大，应使用基础迭代法。

如果非要尝试用 Stream API 思想来处理，可能是一个混合方案，比如先将字符串转换为字符流，然后通过某种方式（例如，使用 `AtomicReference` 或自定义状态类）来模拟状态，但这通常不被认为是 Stream API 的最佳实践。因此，在这里我们不提供一个复杂的纯Stream方案，而是强调其在这个特定问题上的局限性，并推荐更合适的方案。

3. 读取文件中的相同字符

以上方法都是针对内存中的 `String` 对象。如果我们需要从文件中读取内容并处理其中的相同字符，就需要结合文件 I/O。

3.1 逐行读取与处理

最常见的方式是使用 `BufferedReader` 逐行读取文件内容，然后将每一行作为字符串传递给上述方法进行处理。

import ;
import ;
import ;
import ;
public class FileCharProcessor {
public static void processFileForCharFrequency(String filePath) {
("Processing file for char frequency: " + filePath);
Map<Character, Integer> totalCharCounts = new HashMap<>();
try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
String line;
while ((line = ()) != null) {
// 处理每一行，统计字符频率
Map<Character, Integer> lineCounts = (line);
((character, count) ->
(character, count, Integer::sum)
);
}
} catch (IOException e) {
("Error reading file: " + ());
}
("Total char counts in file: " + totalCharCounts);
}
public static void processFileForConsecutiveChars(String filePath) {
("Processing file for consecutive chars: " + filePath);
try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
String line;
int lineNumber = 1;
while ((line = ()) != null) {
// 处理每一行，查找连续字符
List<<Character, Integer>> consecutiveChars = (line);
("Line " + lineNumber + ": " + consecutiveChars);
lineNumber++;
}
} catch (IOException e) {
("Error reading file: " + ());
}
}
public static void main(String[] args) throws IOException {
// 创建一个临时文件用于测试
String testFilePath = "";
try ( writer = new (testFilePath)) {
("Hello World!");
("AAABBC");
("DDDEEFFG");
("single line with only one character");
}
processFileForCharFrequency(testFilePath);
processFileForConsecutiveChars(testFilePath);
// 清理临时文件
new (testFilePath).delete();
}
}

解释：

`BufferedReader` 和 `FileReader` 是 Java 中用于高效读取文本文件的标准类。`BufferedReader` 提供了缓冲功能，能显著提高读取性能。
`try-with-resources` 语句确保 `BufferedReader` 在使用完毕后自动关闭，防止资源泄露。
`()` 逐行读取文件。
对于统计字符频率，我们需要将每行的统计结果合并到总的 `totalCharCounts` 中，这里使用了 `()` 方法。
对于连续字符，可以按行显示结果，或者根据需求进行更复杂的跨行处理（这会更复杂，需要自定义缓冲区和状态管理）。

3.2 逐字符读取与处理（适用于超大文件）

如果文件非常大，无法一次性加载到内存中（即使是逐行），或者我们关心的是跨行边界的连续字符，那么就需要逐字符读取文件。

import ;
import ;
import ;
import ;
import ;
import ;
import ;
public class LargeFileCharProcessor {
/
* 逐字符处理文件，查找连续相同的字符。
* 适用于需要跨行处理连续字符或文件非常大的情况。
*
* @param filePath 文件路径
* @return 一个List，包含所有连续字符块
*/
public static List<<Character, Integer>> findConsecutiveCharsInLargeFile(String filePath) {
List<<Character, Integer>> result = new ArrayList<>();
// PushbackReader 允许“推回”最近读取的一个或多个字符，方便实现向前看的功能。
// 这里为了简化，仅使用普通FileReader，但对于更复杂的分析，PushbackReader会很有用。
try (FileReader reader = new FileReader(filePath)) {
int charCode; // 读取到的字符的Unicode值
char previousChar = 0; // 记录前一个字符
int currentCount = 0; // 记录当前连续字符的次数
boolean firstChar = true;
while ((charCode = ()) != -1) { // -1 表示文件末尾
char currentChar = (char) charCode;
if (firstChar) {
previousChar = currentChar;
currentCount = 1;
firstChar = false;
} else if (currentChar == previousChar) {
currentCount++;
} else {
// 遇到了不同的字符，将前一个连续字符块的结果保存
(new <>(previousChar, currentCount));
// 重置，开始计数新的连续字符块
previousChar = currentChar;
currentCount = 1;
}
}
// 循环结束后，最后一个连续字符块的结果需要手动添加
if (currentCount > 0) {
(new <>(previousChar, currentCount));
}
} catch (IOException e) {
("Error reading large file: " + ());
}
return result;
}
public static void main(String[] args) throws IOException {
String testFilePath = "";
try ( writer = new (testFilePath)) {
("AAA"); // 注意这里的换行符 '' 也是一个字符
("BBB");
("CCC");
("DDDEEEF");
}
("Consecutive chars in large file: " + findConsecutiveCharsInLargeFile(testFilePath));
new (testFilePath).delete();
}
}

解释：

使用 `FileReader` 逐个字符地读取文件内容。`read()` 方法返回读取到的字符的 Unicode 值（一个 `int`），如果到达文件末尾则返回 `-1`。
通过 `previousChar` 和 `currentCount` 变量来追踪连续字符的状态。
这种方法可以处理跨行边界的连续字符，例如 `ABBA`，其中的 `` 会被视为一个不同的字符，中断 'B' 的连续性。
处理文件末尾时，需要将最后一个连续字符块的结果手动添加到列表中。
对于极大的文件，可以结合 `BufferedReader`（它内部使用字符数组缓冲）来提高 `read()` 的效率，同时保持逐字符处理的逻辑。

4. 性能考量与最佳实践

选择哪种方法取决于具体需求和场景：

数据量：

小字符串（几K）： 任何方法都可以，Stream API 可能最简洁。
中等字符串（几十K到几M）： 迭代法或正则表达式通常表现良好。Stream API 可能会有轻微的开销，但通常可接受。
大字符串（几十M以上）或文件： 迭代法（尤其是逐字符文件读取）是首选，避免将整个内容加载到内存中。


可读性与维护性：

统计所有字符频率：Stream API 的 `groupingBy` 简洁且可读性强。
查找连续字符：基础迭代法通常是最清晰、最容易理解和调试的。正则表达式在模式复杂时可能难以理解，但对于简单的连续匹配非常简洁。


性能要求： 基础迭代法通常提供最好的性能，因为它避免了正则表达式引擎的额外开销或 Stream API 内部的装箱/拆箱和函数调用开销。
字符集： Java 的 `char` 类型是 16 位 Unicode 字符，可以处理大多数国际字符。在进行字符比较时，请确保理解 Unicode 字符的等价性（例如，某些字符可能在视觉上相同但 Unicode 值不同）。

在 Java 中“读取相同字符”可以根据具体需求（统计所有出现次数 vs. 查找连续出现）选择不同的方法。对于统计所有字符频率，`HashMap` 迭代法和 Java 8 Stream API 的 `groupingBy` 都非常高效且易于实现。对于查找连续字符，基础迭代法提供了最佳的性能和控制力，而正则表达式则以其简洁性提供了一种快速解决方案。当处理文件时，需要将这些核心逻辑与文件 I/O 机制（如 `BufferedReader`）结合起来，甚至需要考虑逐字符处理以应对超大文件或跨行连续字符的需求。理解每种方法的优缺点，将帮助您在实际项目中做出最明智的选择。

2025-10-16

---

上一篇：深入剖析Java代码：从基础语法到高级特性精解

下一篇：Java代码的艺术：构建优雅、高效与易维护的编程实践