如果性能很重要，我应该使用Java的String.format（）吗？

我们必须一直构建String以便进行日志输出等等。在JDK版本中，我们了解了何时使用StringBuffer（很多追加，线程安全）和StringBuilder（很多追加，非线程安全）。

有什么使用建议String.format()？是高效的，还是在性能很重要的情况下，我们被迫坚持采用单线连接？

例如丑陋的旧风格，

String s = "What do you get if you multiply " + varSix + " by " + varNine + "?";

与整洁的新样式（String.format，可能会更慢）相比，

String s = String.format("What do you get if you multiply %d by %d?", varSix, varNine);

注意：我的特定用例是整个代码中数百个“单行”日志字符串。它们不涉及循环，所以StringBuilder也太笨重。我String.format()特别感兴趣。

我编写了一个小类进行测试，该类具有两者的更好性能，并且+领先于格式。以5到6的倍数进行尝试

import java.io.*;
import java.util.Date;

public class StringTest{

    public static void main( String[] args ){
    int i = 0;
    long prev_time = System.currentTimeMillis();
    long time;

    for( i = 0; i< 100000; i++){
        String s = "Blah" + i + "Blah";
    }
    time = System.currentTimeMillis() - prev_time;

    System.out.println("Time after for loop " + time);

    prev_time = System.currentTimeMillis();
    for( i = 0; i<100000; i++){
        String s = String.format("Blah %d Blah", i);
    }
    time = System.currentTimeMillis() - prev_time;
    System.out.println("Time after for loop " + time);

    }
}

对不同的N运行上面的结果表明，两者的行为都是线性的，但String.format速度要慢5-30倍。

原因是在当前实现中，String.format首先使用正则表达式解析输入，然后填充参数。另一方面，与plus的连接通过javac（而不是JIT）进行优化，并StringBuilder.append直接使用。

我使用了hhafez代码并添加了一个内存测试：

private static void test() {
    Runtime runtime = Runtime.getRuntime();
    long memory;
    ...
    memory = runtime.freeMemory();
    // for loop code
    memory = memory-runtime.freeMemory();

我为每种方法，“ +”运算符String.format和StringBuilder（调用toString（））分别运行此命令，因此所使用的内存不会受到其他方法的影响。我添加了更多串联，使字符串成为“ Blah” + i +“ Blah” + i +“ Blah” + i +“ Blah”。

结果如下（每次平均运行5次）：
接近时间（毫秒）分配的内存（长）
'+'运算符747 320,504
String.format 16484 373,312
StringBuilder 769 57,344

我们可以看到String'+'和StringBuilder在时间上实际上是相同的，但是StringBuilder在内存使用方面效率更高。当我们在足够短的时间间隔内进行许多日志调用（或任何其他其他涉及字符串的语句）时，这非常重要，这样垃圾收集器将无法清除由'+'运算符引起的许多字符串实例。

还有一个注意事项，顺便说一句，不要忘记在构造消息之前检查日志记录级别。

结论：

1. 我将继续使用StringBuilder。
2. 我的时间太多或生活太少。

这里介绍的所有基准测试都有一些缺陷，因此结果不可靠。

我很惊讶没有人使用JMH进行基准测试，所以我做到了。

结果：

Benchmark             Mode  Cnt     Score     Error  Units
MyBenchmark.testOld  thrpt   20  9645.834 ± 238.165  ops/s  // using +
MyBenchmark.testNew  thrpt   20   429.898 ±  10.551  ops/s  // using String.format

单位是每秒的操作数，越多越好。基准源代码。使用了OpenJDK IcedTea 2.5.4 Java虚拟机。

因此，旧样式（使用+）要快得多。

JAVAC 1.6会自动将您以前的丑陋样式编译为：

StringBuilder sb = new StringBuilder("What do you get if you multiply ");
sb.append(varSix);
sb.append(" by ");
sb.append(varNine);
sb.append("?");
String s =  sb.toString();

因此，这与使用StringBuilder绝对没有区别。

String.format具有更大的重量，因为它创建了一个新的Formatter，解析了您的输入格式字符串，创建了一个StringBuilder，将所有内容附加到其上并调用toString（）。

Java的String.format的工作方式如下：

1. 它解析格式字符串，爆炸成格式块列表
2. 它迭代格式块，渲染成StringBuilder，它基本上是一个数组，可以通过复制到新数组来根据需要调整自身大小。这是必要的，因为我们尚不知道分配最终String的大小
3. StringBuilder.toString（）将其内部缓冲区复制到新的String中

如果此数据的最终目的地是流（例如，渲染网页或写入文件），则可以将格式块直接组装到流中：

new PrintStream(outputStream, autoFlush, encoding).format("hello {0}", "world");

我推测优化器将优化格式字符串处理。如果是这样，您将获得同等的摊销性能，可以手动将String.format展开为StringBuilder。

为了扩展/更正上面的第一个答案，实际上不是String.format会帮助您进行翻译。
String.format将帮助您的是当您打印日期/时间（或数字格式等）时，本地化（l10n）有所不同（即，某些国家/地区将打印04Feb2009，而其他国家/地区将打印Feb042009）。
对于翻译，您只是在谈论将任何可外部化的字符串（例如错误消息和诸如此类的东西）移到属性束中，以便可以使用ResourceBundle和MessageFormat将正确的束用于正确的语言。

综上所述，我认为在性能方面，String.format与普通串联取决于您的喜好。如果您希望查看对.format的调用而不是串联，那么请务必这样做。
毕竟，对代码的读取远比其编写的要多。

在您的示例中，性能probalby并没有太大不同，但是还有其他需要考虑的问题：即内存碎片。即使是串联操作，它也会创建一个新字符串，即使它是临时字符串也是如此（GC需要花费时间，这需要更多工作）。String.format（）更具可读性，并且涉及的碎片更少。

另外，如果您经常使用一种特定的格式，请不要忘记可以直接使用Formatter（）类（所有String.format（）所做的都是实例化一个使用Formatter的实例）。

另外，您还应注意其他事项：注意使用substring（）。例如：

String getSmallString() {
  String largeString = // load from file; say 2M in size
  return largeString.substring(100, 300);
}

该大字符串仍在内存中，因为这正是Java子字符串的工作方式。更好的版本是：

  return new String(largeString.substring(100, 300));

要么

  return String.format("%s", largeString.substring(100, 300));

如果您同时执行其他操作，则第二种形式可能更有用。

通常，您应该使用String.Format，因为它相对较快并且支持全球化（假设您实际上是在尝试编写用户可以读取的内容）。如果您要翻译一个字符串而不是每个语句3个或更多的字符串，这也使全球化变得更加容易（尤其是对于语法结构截然不同的语言）。

现在，如果您从不打算翻译任何内容，则可以依靠Java内置的+运算符到的转换StringBuilder。或StringBuilder显式使用Java 。

从Logging角度来看的另一种观点。

我看到了很多与登录此线程有关的讨论，因此想在回答中增加我的经验。可能有人会发现它有用。

我猜想使用格式化程序进行记录的动机来自避免字符串串联。基本上，如果您不打算记录字符串，则不需要字符串concat的开销。

除非您要登录，否则您实际上不需要concat / format。可以说是否定义了这样的方法

public void logDebug(String... args, Throwable t) {
    if(debugOn) {
       // call concat methods for all args
       //log the final debug message
    }
}

在这种方法中，如果cancat / formatter是一条调试消息且debugOn = false，则根本不会真正调用它

尽管在这里使用StringBuilder代替formatter还是更好。主要动机是避免任何这种情况。

同时，我不喜欢为每个日志记录语句添加“ if”块，因为

• 它影响可读性
• 减少我的单元测试的覆盖范围-当您要确保每行都经过测试时，这很令人困惑。

因此，我更喜欢使用上面的方法创建一个日志记录实用工具类，并在各处使用它，而不必担心性能下降以及与此有关的任何其他问题。

我刚刚修改了hhafez的测试以包含StringBuilder。在XP上使用jdk 1.6.0_10客户端，StringBuilder比String.format快33倍。使用-server开关将系数降低到20。

public class StringTest {

   public static void main( String[] args ) {
      test();
      test();
   }

   private static void test() {
      int i = 0;
      long prev_time = System.currentTimeMillis();
      long time;

      for ( i = 0; i < 1000000; i++ ) {
         String s = "Blah" + i + "Blah";
      }
      time = System.currentTimeMillis() - prev_time;

      System.out.println("Time after for loop " + time);

      prev_time = System.currentTimeMillis();
      for ( i = 0; i < 1000000; i++ ) {
         String s = String.format("Blah %d Blah", i);
      }
      time = System.currentTimeMillis() - prev_time;
      System.out.println("Time after for loop " + time);

      prev_time = System.currentTimeMillis();
      for ( i = 0; i < 1000000; i++ ) {
         new StringBuilder("Blah").append(i).append("Blah");
      }
      time = System.currentTimeMillis() - prev_time;
      System.out.println("Time after for loop " + time);
   }
}

尽管这听起来可能很激烈，但我认为它仅在极少数情况下才有意义，因为绝对数字非常低：一百万个简单String.format调用的4 s没问题-只要我将它们用于日志记录或喜欢。

更新：正如sjbotha在评论中指出的那样，StringBuilder测试无效，因为它缺少final .toString()。

我的机器上从String.format(.)到的正确加速因子StringBuilder是23（带-server开关的16 ）。

这是hhafez条目的修改版本。它包括一个字符串生成器选项。

public class BLA
{
public static final String BLAH = "Blah ";
public static final String BLAH2 = " Blah";
public static final String BLAH3 = "Blah %d Blah";


public static void main(String[] args) {
    int i = 0;
    long prev_time = System.currentTimeMillis();
    long time;
    int numLoops = 1000000;

    for( i = 0; i< numLoops; i++){
        String s = BLAH + i + BLAH2;
    }
    time = System.currentTimeMillis() - prev_time;

    System.out.println("Time after for loop " + time);

    prev_time = System.currentTimeMillis();
    for( i = 0; i<numLoops; i++){
        String s = String.format(BLAH3, i);
    }
    time = System.currentTimeMillis() - prev_time;
    System.out.println("Time after for loop " + time);

    prev_time = System.currentTimeMillis();
    for( i = 0; i<numLoops; i++){
        StringBuilder sb = new StringBuilder();
        sb.append(BLAH);
        sb.append(i);
        sb.append(BLAH2);
        String s = sb.toString();
    }
    time = System.currentTimeMillis() - prev_time;
    System.out.println("Time after for loop " + time);

}

}

循环391之后的时间循环4163之后的时间循环227之后的时间

答案很大程度上取决于特定的Java编译器如何优化其生成的字节码。字符串是不可变的，从理论上讲，每个“ +”操作都可以创建一个新字符串。但是，您的编译器几乎可以肯定地优化了构建长字符串的临时步骤。上面的两行代码完全有可能生成完全相同的字节码。

唯一真正了解的方法是在当前环境中迭代测试代码。编写一个QD应用程序，以迭代方式将字符串连接起来，并查看它们如何彼此超时。

考虑"hello".concat( "world!" )在串联中使用少量字符串。它的性能可能比其他方法更好。

如果您有3个以上的字符串，则可以考虑使用StringBuilder或仅使用String，具体取决于您使用的编译器。