String 类中的替换方法

String 类提供了两个重载的 replace 方法，以及 replaceAll 和 replaceFirst 方法。

String replace(char oldChar, char newChar)

这是最基础的替换方法,用于将字符串中所有的 旧字符 替换为 新字符。

• 语法: public String replace(char oldChar, char newChar)
• 参数:
  • oldChar: 要被替换的字符。
  • newChar: 用于替换的新字符。
• 返回值: 返回一个新的字符串，所有 oldChar 都被替换为 newChar，原始字符串不会被修改（因为 String 是不可变的）。
• 特点: 区分大小写。

示例代码:

public class ReplaceExample {
    public static void main(String[] args) {
        String str = "Hello World, Java is fun.";
        // 将所有的 'l' 替换为 'p'
        String newStr = str.replace('l', 'p');
        System.out.println("原始字符串: " + str);
        System.out.println("替换后字符串: " + newStr);
        // 输出: Heppo Worpd, Java is fun.
    }
}

String replace(CharSequence target, CharSequence replacement)

这是一个更通用的方法,可以替换字符串中的 子串（CharSequence 包括 String）。

• 语法: public String replace(CharSequence target, CharSequence replacement)
• 参数:
  • target: 要被替换的子串。
  • replacement: 用于替换的新子串。
• 返回值: 返回一个新的字符串，所有 target 子串都被替换为 replacement。
• 特点: 区分大小写。

示例代码:

public class ReplaceExample {
    public static void main(String[] args) {
        String str = "I like Java, and Java is powerful.";
        // 将所有的 "Java" 替换为 "Python"
        String newStr = str.replace("Java", "Python");
        System.out.println("原始字符串: " + str);
        System.out.println("替换后字符串: " + newStr);
        // 输出: I like Python, and Python is powerful.
    }
}

String replaceAll(String regex, String replacement)

这个方法使用 正则表达式 来进行匹配和替换，它会替换所有与正则表达式匹配的子串。

• 语法: public String replaceAll(String regex, String replacement)
• 参数:
  • regex: 正则表达式，注意，如果字符串中包含正则的特殊字符（如 等），需要转义。
  • replacement: 替换的字符串，可以使用 引用正则表达式中的捕获组。
• 返回值: 返回一个新的字符串。
• 特点: 强大的模式匹配能力。

示例代码:

public class ReplaceAllExample {
    public static void main(String[] args) {
        String str = "The price is $123.45 and the discount is 10%.";
        // 使用正则表达式，将所有数字（一个或多个）替换为 "[NUMBER]"
        // \\d+ 是一个正则表达式，表示一个或多个数字
        String newStr = str.replaceAll("\\d+", "[NUMBER]");
        System.out.println("原始字符串: " + str);
        System.out.println("替换后字符串: " + newStr);
        // 输出: The price is $[NUMBER].[NUMBER] and the discount is [NUMBER]%.
        // 替换掉所有的标点符号
        String noPunctuationStr = str.replaceAll("[.,$%]", "");
        System.out.println("去除标点后: " + noPunctuationStr);
        // 输出: The price is 12345 and the discount is 10
    }
}

String replaceFirst(String regex, String replacement)

与 replaceAll 类似，但它只替换 第一个 与正则表达式匹配的子串。

• 语法: public String replaceFirst(String regex, String replacement)
• 参数:
  • regex: 正则表达式。
  • replacement: 替换的字符串。
• 返回值: 返回一个新的字符串。

示例代码:

public class ReplaceFirstExample {
    public static void main(String[] args) {
        String str = "apple orange apple banana";
        // 只替换第一个 "apple"
        String newStr = str.replaceFirst("apple", "grape");
        System.out.println("原始字符串: " + str);
        System.out.println("替换后字符串: " + newStr);
        // 输出: grape orange apple banana
    }
}

StringBuilder 和 StringBuffer 中的替换方法

StringBuilder 和 StringBuffer 是可变的字符序列，它们提供了直接在原对象上进行修改的替换方法。

StringBuilder replace(int start, int end, String str)

这个方法用指定的字符串替换 StringBuilder 中从 start (包含) 到 end (不包含) 位置的字符。

• 语法: public StringBuilder replace(int start, int end, String str)
• 参数:
  • start: 开始位置的索引 (包含)。
  • end: 结束位置的索引 (不包含)。
  • str: 用于替换的字符串。
• 返回值: 返回 StringBuilder 对象本身，因此可以支持链式调用。
• 特点: 直接修改原对象，效率高，适合在循环中构建字符串。

示例代码:

public class StringBuilderReplaceExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello World");
        // 替换索引 6 到 11 (即 "World") 为 "Java"
        sb.replace(6, 11, "Java");
        System.out.println(sb.toString());
        // 输出: Hello Java
        // 链式调用
        sb.replace(0, 5, "Hi").append("!");
        System.out.println(sb.toString());
        // 输出: Hi Java!
    }
}

核心区别与如何选择

如何选择？

1. 如果你只是想进行简单的、一次性的替换：

   • 替换单个字符或固定子串,用 String.replace(char, char) 或 String.replace(CharSequence, CharSequence)。
   • 需要按规则（如所有数字、所有空格）替换，用 String.replaceAll()。

2. 如果你需要在循环或复杂逻辑中多次修改一个字符串：

   • 务必使用 StringBuilder 或 StringBuffer，反复使用 String.replace() 会产生大量中间字符串对象，导致严重的性能问题和内存浪费。

3. 如果你只想替换第一个匹配项：

   • 用 String.replaceFirst()。

常见误区与注意事项

1. String 的不可变性： 这是 Java 开发者最容易犯的错误之一。String 的所有 replace 方法都不会改变原始字符串，它们总是返回一个新的字符串。

   String s = "hello";
   s.replace('h', 'H'); // 这行代码没有效果，返回的新字符串没有被接收
   System.out.println(s); // 输出仍然是 "hello"
   // 正确做法
   s = s.replace('h', 'H');
   System.out.println(s); // 输出 "Hello"

2. 正则表达式的特殊字符： 在 replaceAll 中，如果你的 target 包含 ^ [ ] \ 等特殊字符，它们会被解释为正则元字符，如果你想匹配这些字符本身，需要用 \ 进行转义。

   String str = "file.txt.bak";
   // 错误写法，. 匹配任意字符
   // str.replace(".", "_"); // 结果会是 "file_txt_bak"
   // 正确写法，需要转义
   str = str.replace("\\.", "_"); // 结果是 "file_txt_bak"

   在 Java 字符串中，一个 \ 需要写成 \\ 才能表示一个字面的 \。

3. StringBuilder 的索引范围： StringBuilder.replace(start, end, str) 中的 end 是 不包含 的，这与 String.substring() 的行为一致，要确保索引不越界。

希望这份详细的解释能帮助你完全掌握 Java 中 replace 的用法！