在Java中使用String.format而不是字符串连接是更好的做法吗？

Question

在Java中使用String.format和String连接之间是否存在明显的差异？

我倾向于使用String.format，但偶尔会滑倒并使用连接。我想知道一个人是否比另一个好。

我看到它的方式，String.format给你“格式化”字符串更多的权力;和连接意味着您不必担心意外地添加额外的％s或丢失一个％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

我没有做过任何具体的基准测试，但我认为连接可能会更快。 String.format（）创建一个新的Formatter，然后创建一个新的StringBuilder（大小只有16个字符）。这是一个相当大的开销，特别是如果你要格式化一个更长的字符串并且StringBuilder不断调整大小。

但是，连接不太有用且难以阅读。与往常一样，值得对代码进行基准测试，看看哪个更好。在资源包，区域设置等加载到内存中并且代码被JIT打开后，服务器应用程序中的差异可以忽略不计。

也许作为一种最佳实践，使用正确大小的StringBuilder（可附加）和Locale创建自己的Formatter是个好主意，如果你有很多格式要做，那就使用它。

Answer 3

可能存在明显的差异。

String.format非常复杂并且在下面使用正则表达式，所以不要习惯在任何地方使用它，而只是在你需要它的地方。

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

Answer 4

您无法通过上面的程序比较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在这里工作得更快。这是因为创建的初始对象可能不会被释放，并且可能存在内存分配问题，从而导致性能问题。

Answer 5

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

Answer 6

我认为我们可以选择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毫秒

MessageFormat = 200毫秒

更新：

根据SonarLint报告，应正确使用Printf样式的格式字符串（squid：S3457）

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

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

连接= 69毫秒格式= 1107毫秒格式：花括号= 416毫秒 MessageFormat = 215毫秒 MessageFormat：花括号= 2517毫秒

我的结论：正如我在上面强调的那样，使用带有花括号的String.format应该是获得良好可读性和性能的好选择。

Answer 7

关于表现：

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");
}

时间结果如下：

连接= 265毫秒
格式= 4141毫秒

因此，连接比String.format快得多。

Answer 8

由于有关于性能的讨论，我想我会添加一个包含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 [Testman] - 浓度= 134毫秒
2012-01-11 16：30：46,313 INFO [TestMain] - String Builder = 117毫秒

Answer 9

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

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

Answer 10

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

你在那里得到了答案。

这是个人品味的问题。

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

Answer 11

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

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 12

这是与上面相同的测试，修改了在StringBuilder上调用toString（）方法。下面的结果显示StringBuilder方法比使用+运算符的字符串连接稍慢。

file：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 13

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

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

Answer 14

通常，字符串连接应优先于String.format。后者有两个主要缺点：

它不对以本地方式构建的字符串进行编码。
构建过程以字符串形式编码。

从第1点开始，我的意思是无法理解String.format()调用在单个顺序传递中正在做什么。一个人被迫在格式字符串和参数之间来回，同时计算参数的位置。对于简短的连接，这不是一个问题。但是，在这些情况下，字符串连接不那么冗长。

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

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

在Java中使用String.format而不是字符串连接是更好的做法吗？

问题描述投票：238回答：14

14个回答

最新问题

在Java中使用String.format而不是字符串连接是更好的做法吗？

问题描述 投票：238回答：14

14个回答

最新问题

问题描述投票：238回答：14