在 Java 中使用 String.format 比字符串连接更好吗？

Question

在 Java 中使用 String.format 和字符串连接之间有明显的区别吗？

我倾向于使用 String.format 但偶尔会滑动并使用串联。 我想知道其中一个是否比另一个更好。

在我看来，String.format 为您提供了更多“格式化”字符串的功能； 连接意味着您不必担心意外添加额外的 %s 或漏掉一个。

String.format 也更短。

哪一种更具可读性取决于您的大脑如何工作。

Answer 1

我建议最好使用 String.format()。 主要原因是 String.format() 可以使用从资源文件加载的文本更轻松地本地化，而如果不为每种语言生成具有不同代码的新可执行文件，则无法本地化串联。

如果您计划使您的应用程序可本地化，您还应该养成为格式标记指定参数位置的习惯：

"Hello %1$s the time is %2$t"

然后可以对其进行本地化并交换名称和时间标记，而无需重新编译可执行文件以考虑到不同的排序。 通过参数位置，您还可以重复使用相同的参数，而无需将其传递到函数两次：

String.format("Hello %1$s, your name is %1$s and the time is %2$t", name, time)

Answer 2

关于性能：

public static void main(String[] args) throws Exception {      
  long start = System.currentTimeMillis();
  for(int i = 0; i < 1000000; i++){
    String s = "Hi " + i + "; Hi to you " + i*2;
  }
  long end = System.currentTimeMillis();
  System.out.println("Concatenation = " + ((end - start)) + " millisecond") ;

  start = System.currentTimeMillis();
  for(int i = 0; i < 1000000; i++){
    String s = String.format("Hi %s; Hi to you %s",i, + i*2);
  }
  end = System.currentTimeMillis();
  System.out.println("Format = " + ((end - start)) + " millisecond");
}

计时结果如下：

• Concatenation = 265 毫秒
• Format = 4141 毫秒

因此，concatenation 比 String.format 快很多。

Answer 3

.format 的一个问题是失去静态类型安全性。 您的格式参数可能太少，并且格式说明符的类型可能错误 - 两者都会导致运行时 IllegalFormatException ，因此您最终可能会得到记录破坏生产的代码。

相反，+ 的参数可以由编译器测试。

安全历史记录 post-tag" title="show questions tagged 'printf'" rel="tag">printf （format 函数是在其上建模的）又长又可怕。

Answer 4

由于有关于性能的讨论，我想我应该添加一个包括 StringBuilder 的比较。 事实上，它比 concat 和 String.format 选项更快。

为了进行同类比较，我在循环中而不是在外部实例化一个新的 StringBuilder （这实际上比仅进行一次实例化要快，很可能是由于在循环末尾重新分配空间的开销）一名建筑商）。

    String formatString = "Hi %s; Hi to you %s";

    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s = String.format(formatString, i, +i * 2);
    }

    long end = System.currentTimeMillis();
    log.info("Format = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        String s = "Hi " + i + "; Hi to you " + i * 2;
    }

    end = System.currentTimeMillis();

    log.info("Concatenation = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        StringBuilder bldString = new StringBuilder("Hi ");
        bldString.append(i).append("; Hi to you ").append(i * 2);
    }

    end = System.currentTimeMillis();

    log.info("String Builder = " + ((end - start)) + " millisecond");

• 2012-01-11 16:30:46,058 INFO [TestMain] - 格式 = 1416 毫秒
• 2012-01-11 16:30:46,190 INFO [TestMain] - 连接 = 134 毫秒
• 2012-01-11 16:30:46,313 INFO [ TestMain] - 字符串生成器 = 117 毫秒

Answer 5

哪一个更具可读性取决于您的头脑如何工作。

你在那里得到了答案。

这是个人品味的问题。

我认为字符串连接速度稍快一些，但这应该可以忽略不计。

Answer 6

这是一个以毫秒为单位的多个样本大小的测试。

public class Time {

public static String sysFile = "/sys/class/camera/rear/rear_flash";
public static String cmdString = "echo %s > " + sysFile;

public static void main(String[] args) {

  int i = 1;
  for(int run=1; run <= 12; run++){
      for(int test =1; test <= 2 ; test++){
        System.out.println(
                String.format("\nTEST: %s, RUN: %s, Iterations: %s",run,test,i));
        test(run, i);
      }
      System.out.println("\n____________________________");
      i = i*3;
  }
}

public static void test(int run, int iterations){

      long start = System.nanoTime();
      for( int i=0;i<iterations; i++){
          String s = "echo " + i + " > "+ sysFile;
      }
      long t = System.nanoTime() - start;   
      String r = String.format("  %-13s =%10d %s", "Concatenation",t,"nanosecond");
      System.out.println(r) ;


     start = System.nanoTime();       
     for( int i=0;i<iterations; i++){
         String s =  String.format(cmdString, i);
     }
     t = System.nanoTime() - start; 
     r = String.format("  %-13s =%10d %s", "Format",t,"nanosecond");
     System.out.println(r);

      start = System.nanoTime();          
      for( int i=0;i<iterations; i++){
          StringBuilder b = new StringBuilder("echo ");
          b.append(i).append(" > ").append(sysFile);
          String s = b.toString();
      }
     t = System.nanoTime() - start; 
     r = String.format("  %-13s =%10d %s", "StringBuilder",t,"nanosecond");
     System.out.println(r);
}

}

TEST: 1, RUN: 1, Iterations: 1
  Concatenation =     14911 nanosecond
  Format        =     45026 nanosecond
  StringBuilder =      3509 nanosecond

TEST: 1, RUN: 2, Iterations: 1
  Concatenation =      3509 nanosecond
  Format        =     38594 nanosecond
  StringBuilder =      3509 nanosecond

____________________________

TEST: 2, RUN: 1, Iterations: 3
  Concatenation =      8479 nanosecond
  Format        =     94438 nanosecond
  StringBuilder =      5263 nanosecond

TEST: 2, RUN: 2, Iterations: 3
  Concatenation =      4970 nanosecond
  Format        =     92976 nanosecond
  StringBuilder =      5848 nanosecond

____________________________

TEST: 3, RUN: 1, Iterations: 9
  Concatenation =     11403 nanosecond
  Format        =    287115 nanosecond
  StringBuilder =     14326 nanosecond

TEST: 3, RUN: 2, Iterations: 9
  Concatenation =     12280 nanosecond
  Format        =    209051 nanosecond
  StringBuilder =     11818 nanosecond

____________________________

TEST: 5, RUN: 1, Iterations: 81
  Concatenation =     54383 nanosecond
  Format        =   1503113 nanosecond
  StringBuilder =     40056 nanosecond

TEST: 5, RUN: 2, Iterations: 81
  Concatenation =     44149 nanosecond
  Format        =   1264241 nanosecond
  StringBuilder =     34208 nanosecond

____________________________

TEST: 6, RUN: 1, Iterations: 243
  Concatenation =     76018 nanosecond
  Format        =   3210891 nanosecond
  StringBuilder =     76603 nanosecond

TEST: 6, RUN: 2, Iterations: 243
  Concatenation =     91222 nanosecond
  Format        =   2716773 nanosecond
  StringBuilder =     73972 nanosecond

____________________________

TEST: 8, RUN: 1, Iterations: 2187
  Concatenation =    527450 nanosecond
  Format        =  10291108 nanosecond
  StringBuilder =    885027 nanosecond

TEST: 8, RUN: 2, Iterations: 2187
  Concatenation =    526865 nanosecond
  Format        =   6294307 nanosecond
  StringBuilder =    591773 nanosecond

____________________________

TEST: 10, RUN: 1, Iterations: 19683
  Concatenation =   4592961 nanosecond
  Format        =  60114307 nanosecond
  StringBuilder =   2129387 nanosecond

TEST: 10, RUN: 2, Iterations: 19683
  Concatenation =   1850166 nanosecond
  Format        =  35940524 nanosecond
  StringBuilder =   1885544 nanosecond

  ____________________________

TEST: 12, RUN: 1, Iterations: 177147
  Concatenation =  26847286 nanosecond
  Format        = 126332877 nanosecond
  StringBuilder =  17578914 nanosecond

TEST: 12, RUN: 2, Iterations: 177147
  Concatenation =  24405056 nanosecond
  Format        = 129707207 nanosecond
  StringBuilder =  12253840 nanosecond

Answer 7

这是与上面相同的测试，但修改为调用 StringBuilder 上的 toString() 方法。 下面的结果表明，StringBuilder 方法仅比使用 + 运算符的字符串连接慢一点。

文件：StringTest.java

class StringTest {

  public static void main(String[] args) {

    String formatString = "Hi %s; Hi to you %s";

    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s = String.format(formatString, i, +i * 2);
    }

    long end = System.currentTimeMillis();
    System.out.println("Format = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        String s = "Hi " + i + "; Hi to you " + i * 2;
    }

    end = System.currentTimeMillis();

    System.out.println("Concatenation = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        StringBuilder bldString = new StringBuilder("Hi ");
        bldString.append(i).append("Hi to you ").append(i * 2).toString();
    }

    end = System.currentTimeMillis();

    System.out.println("String Builder = " + ((end - start)) + " millisecond");

  }
}

Shell 命令：（编译并运行 StringTest 5 次）

> javac StringTest.java
> sh -c "for i in \$(seq 1 5); do echo \"Run \${i}\"; java StringTest; done"

结果：

Run 1
Format = 1290 millisecond
Concatenation = 115 millisecond
String Builder = 130 millisecond

Run 2
Format = 1265 millisecond
Concatenation = 114 millisecond
String Builder = 126 millisecond

Run 3
Format = 1303 millisecond
Concatenation = 114 millisecond
String Builder = 127 millisecond

Run 4
Format = 1297 millisecond
Concatenation = 114 millisecond
String Builder = 127 millisecond

Run 5
Format = 1270 millisecond
Concatenation = 114 millisecond
String Builder = 126 millisecond

Answer 8

String.format() 不仅仅是连接字符串。 例如，您可以使用 String.format() 显示特定区域设置中的数字。

但是，如果您不关心本地化，则没有功能差异。
也许连接比其他连接更快，但在大多数情况下，它可以忽略不计。

Answer 9

一般来说，字符串连接应该优先于String.format。 后者有两个主要缺点：

1. 它不会对要以本地方式构建的字符串进行编码。
2. 构建过程被编码在一个字符串中。

对于第 1 点，我的意思是不可能理解 String.format() 调用在单个顺序传递中执行的操作。 人们被迫在格式字符串和参数之间来回切换，同时计算参数的位置。 对于短连接来说，这不是什么大问题。 然而，在这些情况下，字符串连接就不那么冗长了。

第 2 点，我的意思是构建过程的重要部分是在格式字符串中编码的（使用 DSL）。 使用字符串来表示代码有很多缺点。 它本质上不是类型安全的，并且使语法突出显示、代码分析、优化等变得复杂。

当然，当使用 Java 语言外部的工具或框架时，新的因素可能会发挥作用。

Answer 10

错误的测试重复多次
您应该使用 {} no %s 。

public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis();
for (int i = 0; i < 1000000; i++) {
  String s = "Hi " + i + "; Hi to you " + i * 2;
}
long end = System.currentTimeMillis();
System.out.println("Concatenation = " + ((end - start)) + " millisecond");

start = System.currentTimeMillis();
for (int i = 0; i < 1000000; i++) {
  String s = String.format("Hi %s; Hi to you %s", i, +i * 2);
}
end = System.currentTimeMillis();
System.out.println("Wrong use of the message format  = " + ((end - start)) + " millisecond");

start = System.currentTimeMillis();
for (int i = 0; i < 1000000; i++) {
  String s = String.format("Hi {0}; Hi to you {1}", i, +i * 2);
}
end = System.currentTimeMillis();
System.out.println("Good use of the message format = " + ((end - start)) + " millisecond");

}

Concatenation = 88 millisecond
Wrong use of the message format  = 1075 millisecond 
Good use of the message format = 376 millisecond

Answer 11

我没有做过任何具体的基准测试，但我认为串联可能会更快。 String.format() 创建一个新的 Formatter，后者又创建一个新的 StringBuilder（大小仅为 16 个字符）。 这是相当大的开销，特别是如果您正在格式化较长的字符串并且 StringBuilder 必须不断调整大小。

然而，串联的用处不大，而且更难阅读。 与往常一样，值得对您的代码进行基准测试，看看哪个更好。 将资源包、区域设置等加载到内存中并且对代码进行 JIT 编译后，服务器应用程序中的差异可能可以忽略不计。

也许作为最佳实践，最好使用适当大小的 StringBuilder（可附加）和区域设置创建自己的格式化程序，并在需要进行大量格式化时使用它。

Answer 12

可能存在明显的差异。

String.format 非常复杂，并且在底层使用正则表达式，因此不要养成在任何地方使用它的习惯，而只在需要的地方使用它。

StringBuilder 会快一个数量级（正如这里有人已经指出的那样）。

Answer 13

我认为我们可以使用 MessageFormat.format 因为它应该在可读性和性能方面都很好。

我使用了 Icaro 在上面的答案中使用的相同程序，并通过附加使用 MessageFormat 解释性能数字的代码来增强它。

  public static void main(String[] args) {
    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
      String s = "Hi " + i + "; Hi to you " + i * 2;
    }
    long end = System.currentTimeMillis();
    System.out.println("Concatenation = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
      String s = String.format("Hi %s; Hi to you %s", i, +i * 2);
    }
    end = System.currentTimeMillis();
    System.out.println("Format = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
      String s = MessageFormat.format("Hi %s; Hi to you %s", i, +i * 2);
    }
    end = System.currentTimeMillis();
    System.out.println("MessageFormat = " + ((end - start)) + " millisecond");
  }

串联 = 69 毫秒

格式 = 1435 毫秒

消息格式 = 200 毫秒

更新：

根据 SonarLint 报告，应正确使用 Printf 样式格式字符串 (squid:S3457)

因为 printf 样式 格式字符串在运行时解释，而不是由编译器验证，它们可能包含导致创建错误字符串的错误。 当调用 java.util.Formatter、java 的 format(...) 方法时，此规则静态验证 printf-style 格式字符串与其参数的相关性.lang.String、java.io.PrintStream、MessageFormat 和 java.io.PrintWriter 类以及 java.io.PrintStream 或 java.io.PrintWriter 类的 printf(...) 方法。

我用大括号替换 printf 样式，得到了一些有趣的结果，如下所示。

串联 = 69 毫秒
格式 = 1107 毫秒
格式：大括号 = 416 毫秒
MessageFormat = 215
毫秒
MessageFormat:大括号 = 2517 毫秒

我的结论：
正如我上面强调的，使用带有大括号的 String.format 应该是一个不错的选择，可以获得良好的可读性和性能。

Answer 14

习惯 String.Format 需要一些时间，但在大多数情况下这是值得的。 在 NRA 的世界中（从不重复任何内容），将标记化消息（日志或用户）保存在 Constant 库中（我更喜欢静态类）并根据需要使用 String.Format 调用它们，无论您是否是否本地化。 尝试将这样的库与串联方法一起使用时，使用任何需要串联的方法都更难以阅读、排除故障、校对和管理。 更换是一种选择，但我怀疑它的性能。 经过多年的使用，我对 String.Format 的最大问题是，当我将其传递给另一个函数（如 Msg）时，调用的长度太长，不方便，但是使用自定义函数作为别名很容易解决这个问题。

Answer 15

格式 = 1508 毫秒
连接 = 31 毫秒

进程完成，退出代码为 0

连接比格式好得多。

Answer 16

您无法通过上面的程序比较 String Concatenation 和 String.Format。

您也可以尝试在代码块中互换使用 String.Format 和 Concatenation 的位置，如下所示。

public static void main(String[] args) throws Exception {      
  long start = System.currentTimeMillis();

  for( int i=0;i<1000000; i++){
    String s = String.format( "Hi %s; Hi to you %s",i, + i*2);
  }

  long end = System.currentTimeMillis();
  System.out.println("Format = " + ((end - start)) + " millisecond");
  start = System.currentTimeMillis();

  for( int i=0;i<1000000; i++){
    String s = "Hi " + i + "; Hi to you " + i*2;
  }

  end = System.currentTimeMillis();
  System.out.println("Concatenation = " + ((end - start)) + " millisecond") ;
}

您会惊讶地发现 Format 在这里工作得更快。 这是因为创建的初始对象可能不会被释放，并且内存分配可能存在问题，从而影响性能。