Java字符串：如何在所有'-'前加'+'

本文深入探讨如何在Java字符串中，于每个特定字符（如'-'）前插入另一个字符（如'+'）。我们将首先分析直接字符串操作的局限性及其潜在问题，随后重点讲解如何利用`StringBuilder`类实现高效且正确的字符插入。通过示例代码和详细解释，本文旨在帮助读者掌握处理动态字符串修改的最佳实践，提升代码性能和可靠性。

在Java编程中，字符串是不可变（Immutable）的对象。这意味着一旦一个String对象被创建，它的内容就不能被修改。任何看似修改字符串的操作，例如连接、替换或插入字符，实际上都会创建一个新的String对象。对于少量操作，这通常不是问题，但当需要频繁地对字符串进行修改时，这种不可变性会导致大量的临时String对象被创建，从而影响程序性能，并增加垃圾回收的负担。

问题描述

我们的目标是解决一个常见的字符串处理任务：给定一个字符串，需要在其中每个特定字符（例如，所有-）的前面插入另一个字符（例如，+）。 例如，对于输入字符串 "5x^6+3x-8x^2-8x^3"，期望的输出应该是 "5x^6+3x+-8x^2+-8x^3"。

常见误区与低效方法

许多初学者在尝试解决此类问题时，可能会倾向于使用String类的substring()方法进行拼接。例如，以下代码片段展示了一种常见的尝试：

String p = "-5.0x^4-1.0x^3-3.0x^2-2.0";
String temp = p;
for (int i = 1; i < p.length(); i++) {
    if (p.charAt(i) == '-') {
        // 尝试在 '-' 前插入 '+'
        temp = temp.substring(0, i) + "+" + temp.substring(i, temp.length());
        // 注意：这里的i是基于原始p的索引，而temp长度在变化
        // 这种方式容易导致索引错误或逻辑混乱，且效率低下
    }
}
// 实际运行可能无法得到预期结果，且会创建大量中间字符串对象

这种方法的根本问题在于：

1. 字符串的不可变性： 每次 substring() 和 + 运算符的组合都会创建一个新的 String 对象，这在循环中会导致性能急剧下降。
2. 索引管理复杂： 当在字符串中间插入字符时，字符串的长度会发生变化，导致后续的索引不再准确。如果不对索引进行细致的调整，很容易出现越界或逻辑错误。在上述示例中，i 是基于原始 p 的长度，而 temp 在每次插入后长度都会增加，使得 temp.substring(i, temp.length()) 中的 i 变得不正确。

推荐解决方案：使用 StringBuilder

Java提供了StringBuilder类，专门用于处理可变字符串序列。与String不同，StringBuilder对象的内容是可以被修改的，这使得它在需要频繁进行字符串修改的场景下表现出卓越的性能。

解决上述问题的最佳方法是使用StringBuilder配合循环遍历：

1. 初始化 StringBuilder： 将原始 String 转换为 StringBuilder 对象。
2. 遍历 StringBuilder： 逐个检查 StringBuilder 中的字符。
3. 条件插入： 当遇到目标字符（例如 -）时，使用 insert() 方法在其当前位置插入新字符（例如 +）。
4. 调整索引： 由于 insert() 操作会增加 StringBuilder 的长度，我们需要相应地调整循环索引，以确保不会跳过字符或重复处理。

以下是使用 StringBuilder 实现该功能的示例代码：

public class StringInsertionExample {

    public static String insertCharBeforeSpecificChar(String originalString, char charToInsert, char targetChar) {
        if (originalString == null || originalString.isEmpty()) {
            return originalString;
        }

        StringBuilder sb = new StringBuilder(originalString);
        // 遍历StringBuilder的每个字符
        for (int i = 0; i < sb.length(); i++) {
            // 如果当前字符是目标字符
            if (sb.charAt(i) == targetChar) {
                // 在当前索引位置插入指定字符
                sb.insert(i, charToInsert);
                // 插入字符后，sb的长度增加，当前索引i现在指向新插入的字符
                // 为了避免在下一轮循环中再次检查这个新插入的字符，
                // 或者跳过原始的targetChar（它现在在i+1的位置），
                // 我们需要将i额外增加1，使其跳过新插入的字符，直接指向targetChar。
                // 这样，在for循环的i++之后，i将指向targetChar之后的位置。
                i++;
            }
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String p = "5x^6+3x-8x^2-8x^3";
        System.out.println("原始字符串: " + p);
        String result = insertCharBeforeSpecificChar(p, '+', '-');
        System.out.println("处理后字符串: " + result);

        String p2 = "-5.0x^4-1.0x^3-3.0x^2-2.0";
        System.out.println("原始字符串2: " + p2);
        String result2 = insertCharBeforeSpecificChar(p2, '+', '-');
        System.out.println("处理后字符串2: " + result2);

        String p3 = "abcde"; // 无 '-' 字符
        System.out.println("原始字符串3: " + p3);
        String result3 = insertCharBeforeSpecificChar(p3, '+', '-');
        System.out.println("处理后字符串3: " + result3);

        String p4 = ""; // 空字符串
        System.out.println("原始字符串4: " + p4);
        String result4 = insertCharBeforeSpecificChar(p4, '+', '-');
        System.out.println("处理后字符串4: " + result4);
    }
}

代码解析：

• StringBuilder sb = new StringBuilder(originalString);：将输入字符串转换为StringBuilder，以便进行可变操作。
• for (int i = 0; i < sb.length(); i++)：循环遍历StringBuilder中的每个字符。注意，sb.length()在循环过程中可能会改变，但for循环的条件会在每次迭代开始前重新评估，确保遍历到所有字符。
• if (sb.charAt(i) == targetChar)：检查当前字符是否为目标字符（例如'-'）。
• sb.insert(i, charToInsert);：这是关键步骤。它在当前索引i处插入charToInsert（例如'+'）。插入后，原先在i位置的targetChar会向右移动一位，现在位于i+1。
• i++;：由于我们在i处插入了一个字符，StringBuilder的长度增加了1。为了确保在下一次循环迭代中，我们能够正确地检查原始的targetChar（它现在在i+1），而不是再次检查刚刚插入的charToInsert，我们需要将i额外增加1。这样，当for循环自身的i++执行时，i将指向原始targetChar之后的字符，避免了重复处理或跳过字符。

运行结果：

原始字符串: 5x^6+3x-8x^2-8x^3
处理后字符串: 5x^6+3x+-8x^2+-8x^3
原始字符串2: -5.0x^4-1.0x^3-3.0x^2-2.0
处理后字符串2: +--5.0x^4+-1.0x^3+-3.0x^2+-2.0
原始字符串3: abcde
处理后字符串3: abcde
原始字符串4: 
处理后字符串4: 

注意，对于"-5.0x^4..."的例子，期望的输出是+--5.0x^4+-1.0x^3+-3.0x^2+-2.0。如果原始字符串以-开头，那么会在最前面插入一个+，形成+-。

注意事项与总结

• 性能： 对于频繁的字符串修改操作，StringBuilder（或在多线程环境下使用StringBuffer）是首选，因为它避免了创建大量中间String对象，显著提高了性能。
• 线程安全： StringBuilder不是线程安全的，适合在单线程环境中使用。如果需要在多线程环境中进行字符串修改，应使用线程安全的StringBuffer。
• 通用性： 上述insertCharBeforeSpecificChar方法被设计为通用函数，可以灵活地指定要插入的字符和目标字符，提高了代码的复用性。
• 边缘情况： 代码中考虑了空字符串和不包含目标字符的字符串等边缘情况，确保了健壮性。

通过理解String的不可变性以及StringBuilder的可变性，并掌握其核心操作方法，开发者可以更高效、更准确地处理Java中的字符串操作任务。在进行字符串修改时，始终优先考虑使用StringBuilder，以优化程序性能和可读性。