替换字符串中出现的所有子字符串 - 这在Java中更有效吗？

Question

I know of two ways of replacing all occurrences of substring in a string.

The regex way (assuming "substring-to-be-replaced" doesn't include regex special chars):

String regex = "substring-to-be-replaced" + "+";
Pattern scriptPattern = Pattern.compile(regex);
Matcher matcher = scriptPattern.matcher(originalstring);
newstring = matcher.replaceAll("replacement-substring");

The String.replace() way:

newstring = originalstring.replace("substring-to-be-replaced", "replacement-substring");

Which of the two is more efficient (and why)?

Are there more efficient ways than the above described two?

Answer 1

String.replace() uses regex underneath.

public String replace(CharSequence target, CharSequence replacement) {
      return Pattern.compile(target.toString(), Pattern.LITERAL)
             .matcher(this ).replaceAll(
               Matcher.quoteReplacement(replacement.toString()));
  }

Are there more efficient ways than the above described two?

There are given that you operate on an implementation backed eg, by an array, rather than the immutable String class (since string.replace creates a new string on each invocation). See for instance StringBuilder.replace() .

Compiling a regex incurs quite alot of overhead which is clear when observing the Pattern source code . Luckily, Apache offers an alternative approach in StringUtils.replace() which according to the source code (line #3732) is quite efficient.

Answer 2

Here's the source code from openjdk:

public String replace(CharSequence target, CharSequence replacement) {
    return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
       this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}

Answer 3

而不是使用不可变的string s，使用char数组或其他一些可变类型（如StringBuffer或StringBuilder ）。

Answer 4

没有进行任何分析或基准测试，我会说这是一个相当安全的赌注，如果你不需要正则表达式魔术，那么正则表达式解析器的开销（无论如何，你将获得内存方面的内容）以及CPU使用率）比你在另一端可能获得的成本高得多。

Answer 5

Shouldn't you compare replaceAll 2 times? However, for a single invocation it will hardly be measurable. And will you do millions of comparisions?

Then I would expect 'compile' to be faster, but only, if you don't use a constant String without any pattern-rules.

Where is the problem in writing a micro benchmark? Or look up the source.