Oma*_*eji 252 java string string.format concatenation
String.format在Java中使用和字符串连接之间是否存在明显的差异？
我倾向于使用,String.format但偶尔会滑倒并使用concat.我想知道一个人是否比另一个好.
我看到它的方式,String.format给你"格式化"字符串更多的权力; 和连接意味着您不必担心意外地添加额外的%s或丢失一个%s.
String.format 也更短.
哪一个更具可读性取决于你的头部如何工作.
wor*_*ad3 226
我建议使用它是更好的做法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)
Ica*_*aro 158
关于表现:
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");
}
时间结果如下:
因此,连接比String.format快得多.
Tec*_*rip 37
由于有关性能的讨论,我想我会添加一个包含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");
Rei*_*der 35
一个问题.format是你失去了静态类型的安全性.您的格式参数可能太少,并且您可能为格式说明符设置了错误的类型 - 这两种类型都会导致IllegalFormatException 运行时,因此您最终可能会遇到破坏生产的日志记录代码.
相反,+可以由编译器测试参数.
Thi*_*ilo 17
哪一个更具可读性取决于你的头部如何工作.
你在那里得到了答案.
这是个人品味的问题.
我想,字符串连接速度稍快,但这应该可以忽略不计.
Der*_*mba 14
这是一个测试,有多个样本大小,以毫秒为单位.
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
这是与上面相同的测试,修改了在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
String.format()不仅仅是连接字符串.例如,您可以使用显示特定区域设置中的数字String.format().
但是,如果您不关心本地化,则没有功能差异.也许一个比另一个快,但在大多数情况下它可以忽略不计......
通常，字符串连接应该优先于String.format. 后者有两个主要缺点：
第 1 点，我的意思是不可能String.format()在单个顺序传递中理解调用正在做什么。一个人被迫在格式字符串和参数之间来回移动，同时计算参数的位置。对于短连接，这不是什么大问题。然而，在这些情况下，字符串连接不那么冗长。
第 2 点，我的意思是构建过程的重要部分是在格式字符串中编码的（使用 DSL）。使用字符串来表示代码有很多缺点。它本质上不是类型安全的，并且使语法突出显示、代码分析、优化等复杂化。
当然，在使用 Java 语言外部的工具或框架时，新的因素可能会发挥作用。
| 归档时间： |
|
| 查看次数： |
132163 次 |
| 最近记录： |