Java 删除字符串中的一个字符
Java 中字符串（
方法 1：使用
方法 2：使用
String）是不可变对象，无法直接修改或删除其中的字符，删除字符的核心逻辑是：基于原字符串创建新字符串，排除需要删除的字符。本文结合实际场景，详解 4 种删除字符串中单个字符的方法（删除指定索引、删除指定字符），附完整代码示例和避坑指南。
一、核心前提：字符串不可变性
String 类的底层是不可变的字符数组（final char[] value），所有看似 “修改” 字符串的操作（如删除、替换），本质都是创建新的 String 对象。因此，删除字符的核心是：通过拼接、截取等方式生成不含目标字符的新字符串。二、常用删除方法（按场景分类）
场景 1：删除指定索引位置的字符（最常用）
方法 1：使用 substring() 拼接（基础方案）
String.substring(int beginIndex) 和 String.substring(int beginIndex, int endIndex) 可截取字符串的指定区间，通过拼接 “索引前的子串 + 索引后的子串” 实现删除。语法说明：
substring(beginIndex)：截取从beginIndex到末尾的子串。substring(beginIndex, endIndex)：截取从beginIndex（包含）到endIndex（不包含）的子串。
示例代码：
public class DeleteCharByIndex {
public static void main(String[] args) {
String original = "HelloJava";
int deleteIndex = 5; // 要删除的字符索引（索引从0开始，此处对应 'J'）
// 校验索引合法性（避免 StringIndexOutOfBoundsException）
if (deleteIndex < 0 || deleteIndex >= original.length()) {
System.out.println("索引越界，无法删除");
return;
}
// 拼接：0到deleteIndex的子串 + deleteIndex+1到末尾的子串
String result = original.substring(0, deleteIndex) + original.substring(deleteIndex + 1);
System.out.println("原字符串：" + original); // 输出：HelloJava
System.out.println("删除后：" + result); // 输出：Helloava
}
}
方法 2：使用 StringBuilder/StringBuffer（高效方案）
StringBuilder（非线程安全）和 StringBuffer（线程安全）是可变字符序列，提供 deleteCharAt(int index) 方法直接删除指定索引的字符，效率远高于 substring() 拼接（尤其频繁操作时）。示例代码：
public class DeleteCharWithStringBuilder {
public static void main(String[] args) {
String original = "PythonJava";
int deleteIndex = 6; // 要删除的索引（对应 'J'）
// 1. 转换为 StringBuilder
StringBuilder sb = new StringBuilder(original);
// 2. 删除指定索引的字符
sb.deleteCharAt(deleteIndex);
// 3. 转换回 String
String result = sb.toString();
System.out.println("原字符串：" + original); // 输出：PythonJava
System.out.println("删除后：" + result); // 输出：Pythonava
}
}
场景 2：删除指定字符（第一个 / 最后一个 / 所有出现的）
子场景 1：删除第一个出现的指定字符
结合
indexOf()（查找字符首次出现的索引）和 substring()/StringBuilder 实现：public class DeleteFirstChar {
public static void main(String[] args) {
String original = "Hello World!";
char deleteChar = 'l'; // 要删除的字符
// 1. 查找字符首次出现的索引
int firstIndex = original.indexOf(deleteChar);
if (firstIndex == -1) {
System.out.println("字符不存在，无需删除");
return;
}
// 2. 使用 StringBuilder 删除
StringBuilder sb = new StringBuilder(original);
sb.deleteCharAt(firstIndex);
String result = sb.toString();
System.out.println("原字符串：" + original); // 输出：Hello World!
System.out.println("删除第一个 'l' 后：" + result); // 输出：Helo World!
}
}
子场景 2：删除最后一个出现的指定字符
结合
lastIndexOf()（查找字符最后一次出现的索引）实现：public class DeleteLastChar {
public static void main(String[] args) {
String original = "Hello World!";
char deleteChar = 'l'; // 要删除的字符
// 1. 查找字符最后一次出现的索引
int lastIndex = original.lastIndexOf(deleteChar);
if (lastIndex == -1) {
System.out.println("字符不存在，无需删除");
return;
}
// 2. 使用 substring 拼接删除
String result = original.substring(0, lastIndex) + original.substring(lastIndex + 1);
System.out.println("原字符串：" + original); // 输出：Hello World!
System.out.println("删除最后一个 'l' 后：" + result); // 输出：Hello Word!
}
}
子场景 3：删除所有指定字符（扩展）
若需删除所有指定字符，可使用
replace() 或 StringBuilder 遍历过滤： public class DeleteAllChar {
public static void main(String[] args) {
String original = "Hello Java, Hello Python!";
char deleteChar = 'l'; // 要删除的字符
// 方法 1：replace 替换为空（最简单）
String result1 = original.replace(String.valueOf(deleteChar), "");
System.out.println("replace 删除所有 'l'：" + result1); // 输出：Heo Java, Heo Python!
// 方法 2：StringBuilder 遍历过滤（更灵活）
StringBuilder sb = new StringBuilder();
for (int i = 0; i < original.length(); i++) {
char c = original.charAt(i);
if (c != deleteChar) { // 保留非目标字符
sb.append(c);
}
}
String result2 = sb.toString();
System.out.println("遍历过滤删除所有 'l'：" + result2); // 输出：Heo Java, Heo Python!
}
}
场景 3：正则表达式删除（复杂匹配场景）
若需删除 “符合特定规则” 的字符（如数字、特殊符号），可使用
replaceAll() 结合正则表达式：public class DeleteCharWithRegex { public static void main(String[] args) {
String original = "Java123Python456";
// 示例 1：删除所有数字字符
String result1 = original.replaceAll("\\d", "");
System.out.println("删除所有数字：" + result1); // 输出：JavaPython
// 示例 2：删除第一个数字字符（正则分组）
String result2 = original.replaceFirst("\\d", "");
System.out.println("删除第一个数字：" + result2); // 输出：Java23Python456
// 示例 3：删除指定位置的特殊字符（如删除索引5的字符，正则实现）
int deleteIndex = 5;
String result3 = original.replaceAll("(?<=.{" + deleteIndex + "}).", "");
System.out.println("删除索引5的字符：" + result3); // 输出：Java23Python456（原索引5是'2'，删除后为Java3Python456）
}
}
三、关键注意事项（避坑指南）
1. 索引越界问题
删除指定索引字符时，必须校验索引范围（
0 ≤ index < 字符串长度），否则抛出 StringIndexOutOfBoundsException：// 错误示例：索引越界
String str = "test";
str.substring(0, 5); // 报错：String index out of range: 5
// 正确做法：先校验
if (index >= 0 && index < str.length()) {
// 执行删除操作
} else {
System.out.println("索引不合法");
}
2. 字符不存在的处理
使用
indexOf()/lastIndexOf() 查找字符时，若返回 -1（字符不存在），需避免执行删除操作，否则可能导致错误：String str = "hello";
int index = str.indexOf('z'); // 返回 -1
// 错误：deleteCharAt(-1) 抛出 IndexOutOfBoundsException
// new StringBuilder(str).deleteCharAt(index);
// 正确做法：先判断
if (index != -1) {
// 执行删除
}
3. 空字符串 / 空白字符串处理
若原字符串为空（
""）或仅含空白字符，删除操作需提前判断，避免无意义处理： String str = "";
if (str.isEmpty() || str.isBlank()) {
System.out.println("字符串为空，无需删除");
return;
}
4. 性能选择
- 单次删除操作：
substring()拼接足够简洁，性能无差异。 - 多次 / 频繁删除操作：优先使用
StringBuilder/StringBuffer（避免创建大量临时String对象）。 - 复杂匹配删除：使用正则表达式
replaceAll()/replaceFirst()。
四、方法选择总结
| 应用场景 | 推荐方法 | 优点 | 缺点 |
|---|---|---|---|
| 删除指定索引字符（单次） | substring() 拼接 |
代码简洁，无需额外类 | 多次操作创建临时对象 |
| 删除指定索引字符（多次） | StringBuilder.deleteCharAt() |
高效，可变字符序列 | 需转换类型 |
| 删除第一个 / 最后一个指定字符 | indexOf()/lastIndexOf() + 拼接 |
精准定位，逻辑清晰 | 需处理字符不存在的情况 |
| 删除所有指定字符 | replace() 或遍历过滤 |
简单高效 | 仅适用于单一字符 |
| 复杂规则删除（如数字 / 符号） | 正则表达式 replaceAll() |
灵活适配复杂场景 | 正则语法需掌握 |
五、总结
Java 删除字符串中单个字符的核心是 “创建新字符串排除目标字符”，需根据场景选择方法：
- 基础场景（指定索引）：优先
substring()或StringBuilder； - 字符定位场景（第一个 / 最后一个）：结合
indexOf()/lastIndexOf()； - 复杂匹配场景：使用正则表达式。
浙公网安备 33010602011771号