StringBuilder 与 String 考虑替换

Question

在连接大量字符串时，建议我使用 StringBuilder 来实现：

StringBuilder someString = new StringBuilder("abc");
someString.append("def");
someString.append("123");
someString.append("moreStuff");

与此相反，

String someString = "abc";
someString = someString + "def";
someString = someString + "123";
someString = someString + "moreStuff";

这会导致创建相当多的字符串，而不是一个。

现在，我需要做一件类似的事情，但我不使用串联，而是使用 String 的 replace 方法，如下所示：

String someString = SOME_LARGE_STRING_CONSTANT;
someString = someString.replace("$VARIABLE1", "abc");
someString = someString.replace("$VARIABLE2", "def");
someString = someString.replace("$VARIABLE3", "123");
someString = someString.replace("$VARIABLE4", "moreStuff");

要使用 StringBuilder 完成同样的事情，我必须这样做，只是为了一次替换：

someString.replace(someString.indexOf("$VARIABLE1"), someString.indexOf("$VARIABLE1")+10, "abc");

所以我的问题是：“是使用 String.replace 并创建大量额外的字符串更好，还是仍然使用 StringBuilder 并创建大量冗长的行（如上面的行）更好？”

Answer 1

你猜怎么着？如果您使用 Java 1.5+ 运行，则连接的工作方式与字符串文字相同

  String h = "hello" + "world";

，并且

  String i = new StringBuilder().append("hello").append("world").toString();

是相同的。

所以，编译器已经为你完成了这项工作。

当然更好的是：

 String j = "hellworld"; // ;) 

至于第二个，是的，这是首选，但应该不那么难，具有“搜索和替换”的功能和一些正则表达式 foo

例如，您可以定义一个类似中的方法这个示例：

  public static void replace( String target, String replacement, 
                              StringBuilder builder ) { 
    int indexOfTarget = -1;
    while( ( indexOfTarget = builder.indexOf( target ) ) >= 0 ) { 
      builder.replace( indexOfTarget, indexOfTarget + target.length() , replacement );
    }
  }

您的代码当前看起来像这样：

someString = someString.replace("VARIABLE1", "abc");
someString = someString.replace("VARIABLE2", "xyz");

您所要做的就是抓住文本编辑器的触发器，例如 vi 搜索和替换：

%s/^.*("\(.*\)".\s"\(.*\)");/replace("\1","\2",builder);

读取：“采取括号中的任何内容，看起来像字符串文字，并且把它放在另一个字符串中”。

你的代码很快就会从这个：

someString = someString.replace("VARIABLE1", "abc");
someString = someString.replace("VARIABLE2", "xyz");

变成这个：

replace( "VARIABLE1", "abc", builder );
replace( "VARIABLE2", "xyz", builder );

。

这是一个工作演示：

class DoReplace { 
  public static void main( String ... args ) {
    StringBuilder builder = new StringBuilder(
       "LONG CONSTANT WITH VARIABLE1 and  VARIABLE2 and VARIABLE1 and VARIABLE2");
    replace( "VARIABLE1", "abc", builder );
    replace( "VARIABLE2", "xyz", builder );
    System.out.println( builder.toString() );
  }
  public static void replace( String target, String replacement, 
                              StringBuilder builder ) { 
    int indexOfTarget = -1;
    while( ( indexOfTarget = builder.indexOf( target ) ) > 0 ) { 
      builder.replace( indexOfTarget, indexOfTarget + target.length() , 
                       replacement );
    }
  }
}

Answer 2

我会说使用 StringBuilder，但只需编写一个包装器，使代码更具可读性，从而更易于维护，同时仍然保持效率。 =D

import java.lang.StringBuilder;
public class MyStringBuilder
{
    StringBuilder sb;

    public MyStringBuilder() 
    {
       sb = new StringBuilder();
    }

    public void replace(String oldStr, String newStr)
    {
            int start = -1;
            while ((start = sb.indexOf(oldStr)) > -1)
            {
                    int end = start + oldStr.length(); 
                    sb.replace(start, end, newStr);
            }
    }

    public void append(String str)
    {
       sb.append(str);
    }

    public String toString()
    {
          return sb.toString();
    }

    //.... other exposed methods

    public static void main(String[] args)
    {
          MyStringBuilder sb = new MyStringBuilder();
          sb.append("old old olD dudely dowrite == pwn");
          sb.replace("old", "new");
          System.out.println(sb);
    }
}

输出：

new new olD dudely dowrite == pwn

现在您可以使用新版本，这是一个简单的衬垫

MyStringBuilder mySB = new MyStringBuilder();
mySB.append("old dudley dowrite == pwn");
mySB.replace("old", "new"):

Answer 3

您可以编写一个方法来替换 StringBuilder 字符串的一部分，而不是使用这样的长行，大致如下：

public StringBuilder replace(StringBuilder someString, String replaceWhat, String replaceWith) {
   return someString.replace(someString.indexOf(replaceWhat), someString.indexOf(replaceWhat)+replaceWhat.length(), replaceWith);
}

Answer 4

可能是 String 类内部使用

索引

方法查找旧字符串的索引并将其替换为新字符串。

而且 StringBuilder 不是线程安全的，因此执行速度要快得多。

Answer 5

如果您的字符串确实很大并且您担心性能，我建议您编写一个类，该类采用模板文本和变量列表，然后逐个字符读取源字符串并使用 StringBuilder 构建结果。就 CPU 和内存使用而言，这应该是最高效的。另外，如果您从文件中读取此模板文本，我不会预先将其全部加载到内存中。当您从文件中读取它时，对其进行分块处理。

如果您只是在寻找一种构建字符串的好方法，该方法的效率不如 StringBuilder 但比一遍又一遍地附加字符串更有效，您可以使用 String.format()。它的工作方式类似于 C 语言中的 sprintf()。 MessageFormat.format() 也是一个选项，但它使用 StringBuffer。

这里还有另一个相关问题： Inserting a Java string in another string没有串联？

Answer 6

所有家伙的代码都有一个错误。尝试 yourReplace("x","xy")。它会无限循环

Answer 7

Jam Hong 是正确的 - 上述解决方案都包含无限循环的潜力。我想这里要吸取的教训是，微观优化通常会导致各种可怕的问题，而且并不能真正为您节省太多。尽管如此，这是一个不会无限循环的解决方案。

private static void replaceAll(StringBuilder builder, String replaceWhat, String replaceWith){
    int occuranceIndex = builder.indexOf(replaceWhat);
    int lastReplace = -1;
    while(occuranceIndex >= 0){
        if(occuranceIndex >= lastReplace){
            builder.replace(occuranceIndex, occuranceIndex+replaceWhat.length(), replaceWith);
            lastReplace = occuranceIndex + replaceWith.length();
            occuranceIndex = builder.indexOf(replaceWhat);
        }else{
            break;
        }
    }
}

Answer 8

虽然微观优化确实可能存在问题，但它有时取决于上下文，例如，如果您的替换恰好在具有 10000 次迭代的循环内运行，您将看到与“无用”优化的显着性能差异。

但在大多数情况下，最好在可读性方面犯错误

Answer 9

确实，StringBuilder 往往比手动连接或修改 String 更好，因为 StringBuilder 是可变的，而 String 是不可变的，您需要为每次修改创建一个新的 String。

但需要注意的是，Java 编译器会自动将这样的示例转换为：

String result = someString + someOtherString + anotherString;

转换为类似的内容：

String result = new StringBuilder().append(someString).append(someOtherString).append(anotherString).toString();

也就是说，除非您要替换大量字符串，否则选择更具可读性和更可维护性的那个。微优化的悲惨悲剧。

PS

对于您的代码示例（正如 OscarRyz 指出的那样，如果 someString 中有多个 "$VARIABLE1" ，则该代码示例将不起作用，在这种情况下，您将需要使用循环），您可以将 indexOf 调用的结果缓存在：

someString.replace(someString.indexOf("$VARIABLE1"), someString.indexOf("$VARIABLE1")+10, "abc");

不需要

int index = someString.indexOf("$VARIABLE1");    
someString.replace(index, index+10, "abc");

搜索字符串两次:-)