我建议使用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)

我想我们可以用MessageFormat。格式，因为它应该在可读性和性能方面都很好。

我使用了与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毫秒 MessageFormat = 200毫秒

更新:

根据SonarLint报告，printf风格的格式字符串应该正确使用(squid:S3457)

Because printf-style format strings are interpreted at runtime, rather than validated by the compiler, they can contain errors that result in the wrong strings being created. This rule statically validates the correlation of printf-style format strings to their arguments when calling the format(...) methods of java.util.Formatter, java.lang.String, java.io.PrintStream, MessageFormat, and java.io.PrintWriter classes and the printf(...) methods of java.io.PrintStream or java.io.PrintWriter classes.

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

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

我的结论是: 如上所述，使用String。带尖括号的格式应该是一个很好的选择，以获得良好的可读性和性能。

由于有关于性能的讨论，我想我应该添加一个包含StringBuilder的比较。事实上，它比concat更快，当然也比String更快。格式选项。

为了使这成为一种苹果对苹果的比较，我在循环中而不是在外部实例化了一个新的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] - Format = 1416毫秒 2012-01-11 16:30:46,190 INFO [TestMain] -连接= 134毫秒 2012-01-11 16:30:46,313 INFO [TestMain] - String Builder = 117毫秒

我没有做任何具体的基准测试，但我认为连接可能更快。String.format()创建一个新的Formatter，该Formatter反过来创建一个新的StringBuilder(大小只有16个字符)。这是一个相当大的开销，特别是当您正在格式化一个较长的字符串并且StringBuilder必须不断调整大小时。

然而，串联不太有用，也更难阅读。一如既往，有必要对代码进行基准测试，看看哪个更好。在服务器应用程序中，当你的资源包、locale等加载到内存中，代码被jit后，这些差异可以忽略不计。

也许作为一个最佳实践，它将是一个好主意，创建自己的Formatter与适当大小的StringBuilder(可追加的)和地区，并使用它，如果你有很多格式化要做。

下面是与上面相同的测试，只是修改了对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

.format的一个问题是失去了静态类型安全性。格式的参数可能过少，格式说明符的类型也可能错误——这两种情况都会导致运行时出现IllegalFormatException异常，因此可能会生成破坏生产的日志代码。

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

printf的安全历史(格式化函数是在它的基础上建模的)是漫长而可怕的。