blocks|key|1329666|text|我建议更好的做法是使用String.format()。主要原因是String.format()可以更容易地本地化从资源文件加载的文本，而如果不为每种语言生成具有不同代码的新可执行文件，则无法本地化串联。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1329667|如果你计划你的应用程序是本地化的，你也应该养成为你的格式标记指定参数位置的习惯：|1329668|"Hello+%251$s+the+time+is+%252$t"|code-block|syntax|javascript|1329669|然后可以将其本地化，并交换名称和时间标记，而不需要重新编译可执行文件以说明不同的排序。对于参数位置，您还可以重用相同的参数，而无需将其两次传递到函数中：|1329670|String.format("Hello+%251$s,+your+name+is+%251$s+and+the+time+is+%252$t",+name,+time)|1329671|entityMap^0|B|F|W|F|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

I'd suggest that it is better practice to use <code>String.format()</code>. The main reason is that <code>String.format()</code> can be more easily localised with text loaded from resource files whereas concatenation can't be localised without producing a new executable with different code for each language.

If you plan on your app being localisable you should also get into the habit of specifying argument positions for your format tokens as well:

<pre><code>"Hello %1$s the time is %2$t"
</code></pre>

This can then be localised and have the name and time tokens swapped without requiring a recompile of the executable to account for the different ordering. With argument positions you can also re-use the same argument without passing it into the function twice:

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

blocks|key|1329715|text|String.format()不仅仅是连接字符串。例如，您可以使用String.format()在特定区域设置中显示数字。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1329716|但是，如果你不关心本地化，就没有功能上的区别。也许一个比另一个快，但在大多数情况下，它可以忽略不计。|1329717|entityMap^0|0|F|X|F|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

<code>String.format()</code> is more than just concatenating strings. For example, you can display numbers in a specific locale using <code>String.format()</code>.

However, if you don't care about localisation, there is no functional difference.
Maybe the one is faster than the other, but in most cases it will be negligible..

blocks|key|1544963|text|我没有做任何具体的基准测试，但我认为串联可能会更快。String.format()创建一个新的格式化程序，该格式化程序又创建一个新的StringBuilder+(大小只有16个字符)。这是一个相当大的开销，特别是如果您正在格式化一个较长的字符串，并且StringBuilder必须不断调整大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1544964|但是，连接没有那么有用，也更难阅读。一如既往，在你的代码上做一个基准测试是值得的，看看哪个更好。在将资源包、区域设置等加载到内存中并且代码为JITted之后，服务器应用程序中的差异可能可以忽略不计。|1544965|也许最好的做法是，创建您自己的具有适当大小的StringBuilder+(可追加的)和区域设置的格式化程序，如果您有很多格式化要做的话就使用它。|1544966|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I haven't done any specific benchmarks, but I would think that concatenation may be faster. String.format() creates a new Formatter which, in turn, creates a new StringBuilder (with a size of only 16 chars). That's a fair amount of overhead especially if you are formatting a longer string and StringBuilder keeps having to resize.

However, concatenation is less useful and harder to read. As always, it's worth doing a benchmark on your code to see which is better. The differences may be negligible in server app after your resource bundles, locales, etc are loaded in memory and the code is JITted.

Maybe as a best practice, it would be a good idea to create your own Formatter with a properly sized StringBuilder (Appendable) and Locale and use that if you have a lot of formatting to do.

blocks|key|1545010|text|您不能通过上面的程序比较字符串连接和String.Format。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1545011|您也可以尝试在代码块中互换使用String.Format和连接的位置，如下所示|1545012|public+static+void+main(String[]+args)+throws+Exception+{++++++
++long+start+=+System.currentTimeMillis();

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

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

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

++end+=+System.currentTimeMillis();
++System.out.println("Concatenation+=+"+%2B+((end+-+start))+%2B+"+millisecond")+;
}|code-block|syntax|javascript|1545013|你会惊讶地发现，格式在这里运行得更快。这是因为创建的初始对象可能不会被释放，并且可能存在内存分配问题，从而导致性能问题。|1545014|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You cannot compare String Concatenation and String.Format by the program above.

You may try this also be interchanging the position of using your String.Format and Concatenation in your code block like the below

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

 for( int i=0;i&lt;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&lt;1000000; i++){
 String s = "Hi " + i + "; Hi to you " + i*2;
 }

 end = System.currentTimeMillis();
 System.out.println("Concatenation = " + ((end - start)) + " millisecond") ;
}
</code></pre>

You will be surprised to see that Format works faster here. This is since the intial objects created might not be released and there can be an issue with memory allocation and thereby the performance.

blocks|key|1329855|text|可能会有明显的不同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1329856|String.format相当复杂，并且在底层使用正则表达式，所以不要养成到处使用它的习惯，而只在需要的地方使用它。|offset|length|style|CODE|1329857|StringBuilder的速度会快一个数量级(这里已经有人指出了)。|1329858|entityMap^0|0|0|D|0|0|D|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

There could be a perceptible difference. 

<code>String.format</code> is quite complex and uses a regular expression underneath, so don't make it a habit to use it everywhere, but only where you need it. 

<code>StringBuilder</code> would be an order of magnitude faster (as someone here already pointed out).

blocks|key|1545099|text|这是一个以毫秒为单位的多样本大小的测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1545100|public+class+Time+{

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

public+static+void+main(String[]+args)+{

++int+i+=+1;
++for(int+run=1;+run+<=+12;+run%2B%2B){
++++++for(int+test+=1;+test+<=+2+;+test%2B%2B){
++++++++System.out.println(
++++++++++++++++String.format("\nTEST:+%25s,+RUN:+%25s,+Iterations:+%25s",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%2B%2B){
++++++++++String+s+=+"echo+"+%2B+i+%2B+"+>+"%2B+sysFile;
++++++}
++++++long+t+=+System.nanoTime()+-+start;+++
++++++String+r+=+String.format("++%25-13s+=%2510d+%25s",+"Concatenation",t,"nanosecond");
++++++System.out.println(r)+;


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

++++++start+=+System.nanoTime();++++++++++
++++++for(+int+i=0;i<iterations;+i%2B%2B){
++++++++++StringBuilder+b+=+new+StringBuilder("echo+");
++++++++++b.append(i).append("+>+").append(sysFile);
++++++++++String+s+=+b.toString();
++++++}
+++++t+=+System.nanoTime()+-+start;+
+++++r+=+String.format("++%25-13s+=%2510d+%25s",+"StringBuilder",t,"nanosecond");
+++++System.out.println(r);
}|code-block|syntax|javascript|1545101|}|1545102|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|1545103|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's a test with multiple sample sizes in milliseconds. 

<pre><code>public class Time {

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

public static void main(String[] args) {

 int i = 1;
 for(int run=1; run &lt;= 12; run++){
 for(int test =1; test &lt;= 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&lt;iterations; i++){
 String s = "echo " + i + " &gt; "+ 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&lt;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&lt;iterations; i++){
 StringBuilder b = new StringBuilder("echo ");
 b.append(i).append(" &gt; ").append(sysFile);
 String s = b.toString();
 }
 t = System.nanoTime() - start; 
 r = String.format(" %-13s =%10d %s", "StringBuilder",t,"nanosecond");
 System.out.println(r);
}
</code></pre>

}

<pre><code>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
</code></pre>

blocks|key|1329983|text|习惯String.Format需要一点时间，但在大多数情况下都是值得的。在NRA的世界中(从不重复任何事情)，将您的标记化消息(日志或用户)保存在一个常量库中(我更喜欢相当于静态类的内容)，并根据需要使用String.Format调用它们，这是非常有用的，无论您是否正在本地化。尝试将这样的库与连接方法一起使用时，使用任何需要连接的方法都很难阅读、故障排除、校对和管理。替换是一种选择，但我怀疑它的性能。经过几年的使用，我对String.Format最大的问题是，当我将它传递给另一个函数(如Msg)时，调用的长度太长了，但这很容易通过自定义函数作为别名来解决。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1329984|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It takes a little time to get used to String.Format, but it's worth it in most cases. In the world of NRA (never repeat anything) it's extremely useful to keep your tokenized messages (logging or user) in a Constant library (I prefer what amounts to a static class) and call them as necessary with String.Format regardless of whether you are localizing or not. Trying to use such a library with a concatenation method is harder to read, troubleshoot, proofread, and manage with any any approach that requires concatenation. Replacement is an option, but I doubt it's performant. After years of use, my biggest problem with String.Format is the length of the call is inconveniently long when I'm passing it into another function (like Msg), but that's easy to get around with a custom function to serve as an alias.

Is there a perceptible difference between using <code>String.format</code> and String concatenation in Java?

I tend to use <code>String.format</code> but occasionally will slip and use a concatenation. I was wondering if one was better than the other.

The way I see it, <code>String.format</code> gives you more power in "formatting" the string; and concatenation means you don't have to worry about accidentally putting in an extra %s or missing one out.

<code>String.format</code> is also shorter.

Which one is more readable depends on how your head works.

Is it better practice to use String.format over string Concatenation in Java?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在Java语言中使用String.format和字符串连接有明显的区别吗？我倾向于使用String.format，但偶尔也会滑倒并使用连接。我想知道一个是不是比另一个更好。在我看来，String.format在“格式化”字符串方面为您提供了更多的能力；而连接意味着您不必担心意外地放入额外的%s或遗漏一个%s。Strin...

问在Java语言中，使用String.format而不是字符串连接是不是更好的做法？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java语言中，使用String.format而不是字符串连接是不是更好的做法？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java语言中，使用String.format而不是字符串连接是不是更好的做法？
EN