StringBuilder 与 Java 中 toString() 中的字符串连接
-
20-09-2019 - |
题
鉴于 2 toString()
下面的实现,哪一个是首选:
public String toString(){
return "{a:"+ a + ", b:" + b + ", c: " + c +"}";
}
或者
public String toString(){
StringBuilder sb = new StringBuilder(100);
return sb.append("{a:").append(a)
.append(", b:").append(b)
.append(", c:").append(c)
.append("}")
.toString();
}
?
更重要的是,考虑到我们只有 3 个属性,这可能没有什么区别,但你会在什么时候从 +
连接到 StringBuilder
?
解决方案
版本 1 更可取,因为它更短并且 编译器实际上会将其转换为版本 2 - 没有任何性能差异。
更重要的是,鉴于我们只有3个属性,这可能不会有所作为,但是在什么时候您可以从Concat转到建造者?
当你在循环中连接时 - 通常是编译器无法替换的时候 StringBuilder
通过它自己。
其他提示
关键在于您是在一个地方编写单个串联还是随着时间的推移累积它。
对于您给出的示例,显式使用 StringBuilder 是没有意义的。(查看第一个案例的编译代码。)
但是如果你正在构建一个字符串,例如在循环内,使用 StringBuilder。
为了澄清,假设巨大数组包含数千个字符串,代码如下:
...
String result = "";
for (String s : hugeArray) {
result = result + s;
}
与以下相比,非常浪费时间和内存:
...
StringBuilder sb = new StringBuilder();
for (String s : hugeArray) {
sb.append(s);
}
String result = sb.toString();
我更喜欢:
String.format( "{a: %s, b: %s, c: %s}", a, b, c );
...因为它简短且可读。
我会 不是 优化它以提高速度,除非您在重复次数非常高的循环中使用它 和 测量了性能差异。
我同意,如果您必须输出很多参数,这种形式可能会变得混乱(就像其中一条评论所说的那样)。在这种情况下,我会切换到更具可读性的形式(也许使用 字符串生成器 apache-commons - 取自 matt b) 的答案并再次忽略性能。
在大多数情况下,您不会看到两种方法之间的实际差异,但很容易构建像这样的最坏情况场景:
public class Main
{
public static void main(String[] args)
{
long now = System.currentTimeMillis();
slow();
System.out.println("slow elapsed " + (System.currentTimeMillis() - now) + " ms");
now = System.currentTimeMillis();
fast();
System.out.println("fast elapsed " + (System.currentTimeMillis() - now) + " ms");
}
private static void fast()
{
StringBuilder s = new StringBuilder();
for(int i=0;i<100000;i++)
s.append("*");
}
private static void slow()
{
String s = "";
for(int i=0;i<100000;i++)
s+="*";
}
}
输出是:
slow elapsed 11741 ms
fast elapsed 7 ms
问题是 += 附加到字符串会重建一个新字符串,因此它的成本与字符串的长度(两者的总和)呈线性关系。
所以 - 对于你的问题:
第二种方法会更快,但可读性较差且难以维护。正如我所说,在您的具体情况下,您可能看不到差异。
我还与我的老板在使用追加还是+的问题上发生了冲突。因为他们正在使用追加(我仍然无法弄清楚他们每次创建新对象时都会说的话)。所以我想做一些研发。虽然我喜欢迈克尔·博格沃特的解释,但只是想展示一个解释,如果有人将来真的需要知道的话。
/**
*
* @author Perilbrain
*/
public class Appc {
public Appc() {
String x = "no name";
x += "I have Added a name" + "We May need few more names" + Appc.this;
x.concat(x);
// x+=x.toString(); --It creates new StringBuilder object before concatenation so avoid if possible
//System.out.println(x);
}
public void Sb() {
StringBuilder sbb = new StringBuilder("no name");
sbb.append("I have Added a name");
sbb.append("We May need few more names");
sbb.append(Appc.this);
sbb.append(sbb.toString());
// System.out.println(sbb.toString());
}
}
上述类的反汇编结果为
.method public <init>()V //public Appc()
.limit stack 2
.limit locals 2
met001_begin: ; DATA XREF: met001_slot000i
.line 12
aload_0 ; met001_slot000
invokespecial java/lang/Object.<init>()V
.line 13
ldc "no name"
astore_1 ; met001_slot001
.line 14
met001_7: ; DATA XREF: met001_slot001i
new java/lang/StringBuilder //1st object of SB
dup
invokespecial java/lang/StringBuilder.<init>()V
aload_1 ; met001_slot001
invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
ldc "I have Added a nameWe May need few more names"
invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
aload_0 ; met001_slot000
invokevirtual java/lang/StringBuilder.append(Ljava/lang/Object;)Ljava/lan\
g/StringBuilder;
invokevirtual java/lang/StringBuilder.toString()Ljava/lang/String;
astore_1 ; met001_slot001
.line 15
aload_1 ; met001_slot001
aload_1 ; met001_slot001
invokevirtual java/lang/String.concat(Ljava/lang/String;)Ljava/lang/Strin\
g;
pop
.line 18
return //no more SB created
met001_end: ; DATA XREF: met001_slot000i ...
; ===========================================================================
;met001_slot000 ; DATA XREF: <init>r ...
.var 0 is this LAppc; from met001_begin to met001_end
;met001_slot001 ; DATA XREF: <init>+6w ...
.var 1 is x Ljava/lang/String; from met001_7 to met001_end
.end method
;44-1=44
; ---------------------------------------------------------------------------
; Segment type: Pure code
.method public Sb()V //public void Sb
.limit stack 3
.limit locals 2
met002_begin: ; DATA XREF: met002_slot000i
.line 21
new java/lang/StringBuilder
dup
ldc "no name"
invokespecial java/lang/StringBuilder.<init>(Ljava/lang/String;)V
astore_1 ; met002_slot001
.line 22
met002_10: ; DATA XREF: met002_slot001i
aload_1 ; met002_slot001
ldc "I have Added a name"
invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
pop
.line 23
aload_1 ; met002_slot001
ldc "We May need few more names"
invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
pop
.line 24
aload_1 ; met002_slot001
aload_0 ; met002_slot000
invokevirtual java/lang/StringBuilder.append(Ljava/lang/Object;)Ljava/lan\
g/StringBuilder;
pop
.line 25
aload_1 ; met002_slot001
aload_1 ; met002_slot001
invokevirtual java/lang/StringBuilder.toString()Ljava/lang/String;
invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
pop
.line 28
return
met002_end: ; DATA XREF: met002_slot000i ...
;met002_slot000 ; DATA XREF: Sb+25r
.var 0 is this LAppc; from met002_begin to met002_end
;met002_slot001 ; DATA XREF: Sb+9w ...
.var 1 is sbb Ljava/lang/StringBuilder; from met002_10 to met002_end
.end method
;96-49=48
; ---------------------------------------------------------------------------
从上面两段代码可以看出Michael是对的。每种情况下只创建一个SB对象。
从 Java 1.5 开始,使用“+”和 StringBuilder.append() 进行简单的一行连接会生成完全相同的字节码。
所以为了代码的可读性,使用“+”。
2 个例外:
- 多线程环境:字符串缓冲区
- 循环中的串联:字符串生成器/字符串缓冲区
使用最新版本的Java(1.8)反汇编(javap -c
)显示编译器引入的优化。 +
还有 sb.append()
将生成非常相似的代码。然而,如果我们使用的话,检查行为是值得的 +
在 for 循环中。
在 for 循环中使用 + 添加字符串
爪哇:
public String myCatPlus(String[] vals) {
String result = "";
for (String val : vals) {
result = result + val;
}
return result;
}
字节码:(for
循环摘录)
12: iload 5
14: iload 4
16: if_icmpge 51
19: aload_3
20: iload 5
22: aaload
23: astore 6
25: new #3 // class java/lang/StringBuilder
28: dup
29: invokespecial #4 // Method java/lang/StringBuilder."<init>":()V
32: aload_2
33: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
36: aload 6
38: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
41: invokevirtual #6 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
44: astore_2
45: iinc 5, 1
48: goto 12
使用 stringbuilder.append 添加字符串
爪哇:
public String myCatSb(String[] vals) {
StringBuilder sb = new StringBuilder();
for(String val : vals) {
sb.append(val);
}
return sb.toString();
}
字节Cdoe:(for
循环摘录)
17: iload 5
19: iload 4
21: if_icmpge 43
24: aload_3
25: iload 5
27: aaload
28: astore 6
30: aload_2
31: aload 6
33: invokevirtual #5 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
36: pop
37: iinc 5, 1
40: goto 17
43: aload_2
有一点 明显的差异 尽管。在第一种情况下,其中 +
被用过,新的 StringBuilder
为每个 for 循环迭代创建,并通过执行以下操作来存储生成的结果 toString()
致电(29 至 41)。因此,您正在生成使用时真正不需要的中间字符串 +
运算符在 for
环形。
在 Java 9 中,版本 1 应该更快,因为它被转换为 invokedynamic
称呼。更多详细信息可以参见 JEP-280:
这个想法是用对 java.lang.invoke.StringConcatFactory 的简单 invokedynamic 调用来替换整个 StringBuilder 附加舞蹈,它将接受需要连接的值。
Apache Commons-Lang 有一个 字符串生成器 超级容易使用的类。它在处理追加逻辑以及格式化您希望 toString 的外观方面做得很好。
public void toString() {
ToStringBuilder tsb = new ToStringBuilder(this);
tsb.append("a", a);
tsb.append("b", b)
return tsb.toString();
}
将返回如下输出 com.blah.YourClass@abc1321f[a=whatever, b=foo]
.
或者使用链接以更简洁的形式:
public void toString() {
return new ToStringBuilder(this).append("a", a).append("b", b").toString();
}
或者,如果您想使用反射来包含类的每个字段:
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
如果需要,您还可以自定义 ToString 的样式。
出于性能原因,使用 +=
(String
串联)是不鼓励的。原因是:爪哇 String
是不可变的,每次进行新的串联时都会产生新的 String
已创建(新指纹已与旧指纹不同) 在字符串池中 )。创建新字符串会给 GC 带来压力并减慢程序速度:对象的创建是昂贵的。
下面的代码应该让它更加实用和清晰。
public static void main(String[] args)
{
// warming up
for(int i = 0; i < 100; i++)
RandomStringUtils.randomAlphanumeric(1024);
final StringBuilder appender = new StringBuilder();
for(int i = 0; i < 100; i++)
appender.append(RandomStringUtils.randomAlphanumeric(i));
// testing
for(int i = 1; i <= 10000; i*=10)
test(i);
}
public static void test(final int howMany)
{
List<String> samples = new ArrayList<>(howMany);
for(int i = 0; i < howMany; i++)
samples.add(RandomStringUtils.randomAlphabetic(128));
final StringBuilder builder = new StringBuilder();
long start = System.nanoTime();
for(String sample: samples)
builder.append(sample);
builder.toString();
long elapsed = System.nanoTime() - start;
System.out.printf("builder - %d - elapsed: %dus\n", howMany, elapsed / 1000);
String accumulator = "";
start = System.nanoTime();
for(String sample: samples)
accumulator += sample;
elapsed = System.nanoTime() - start;
System.out.printf("concatenation - %d - elapsed: %dus\n", howMany, elapsed / (int) 1e3);
start = System.nanoTime();
String newOne = null;
for(String sample: samples)
newOne = new String(sample);
elapsed = System.nanoTime() - start;
System.out.printf("creation - %d - elapsed: %dus\n\n", howMany, elapsed / 1000);
}
运行结果报告如下。
builder - 1 - elapsed: 132us
concatenation - 1 - elapsed: 4us
creation - 1 - elapsed: 5us
builder - 10 - elapsed: 9us
concatenation - 10 - elapsed: 26us
creation - 10 - elapsed: 5us
builder - 100 - elapsed: 77us
concatenation - 100 - elapsed: 1669us
creation - 100 - elapsed: 43us
builder - 1000 - elapsed: 511us
concatenation - 1000 - elapsed: 111504us
creation - 1000 - elapsed: 282us
builder - 10000 - elapsed: 3364us
concatenation - 10000 - elapsed: 5709793us
creation - 10000 - elapsed: 972us
不考虑 1 个串联的结果(JIT 尚未完成其工作),即使对于 10 个串联,性能损失也是相关的;对于数千个串联,差异是巨大的。
从这个非常快速的实验中吸取的教训(可以使用上面的代码轻松重现):切勿使用 +=
将字符串连接在一起,即使是在需要一些连接的非常基本的情况下(如上所述,创建新字符串无论如何都是昂贵的,并且会给 GC 带来压力)。
使 toString 方法尽可能具有可读性!
在我的书中,唯一的例外是如果你可以 证明 对我来说,它消耗大量资源:)(是的,这意味着分析)
另请注意,Java 5 编译器生成的代码比 Java 早期版本中使用的手写“StringBuffer”方法更快。如果您使用“+”,则此功能和未来的增强功能都是免费的。
当前编译器是否仍需要使用 StringBuilder 似乎存在一些争论。所以我想我会给出我2美分的经验。
我有一个 JDBC
10k 记录的结果集(是的,我需要一批中的所有记录。)在我的机器上使用 + 运算符大约需要 5 分钟 Java 1.8
. 。使用 stringBuilder.append("")
对于同一查询,只需不到一秒的时间。
所以差别是很大的。在循环内 StringBuilder
速度要快得多。
请参阅下面的示例:
//java8
static void main(String[] args) {
case1();//str.concat
case2();//+=
case3();//StringBuilder
}
static void case1() {
List<Long> savedTimes = new ArrayList();
long startTimeAll = System.currentTimeMillis();
String str = "";
for (int i = 0; i < MAX_ITERATIONS; i++) {
long startTime = System.currentTimeMillis();
str = str.concat(UUID.randomUUID()+"---");
saveTime(savedTimes, startTime);
}
System.out.println("Created string of length:"+str.length()+" in "+(System.currentTimeMillis()-startTimeAll)+" ms");
}
static void case2() {
List<Long> savedTimes = new ArrayList();
long startTimeAll = System.currentTimeMillis();
String str = "";
for (int i = 0; i < MAX_ITERATIONS; i++) {
long startTime = System.currentTimeMillis();
str+=UUID.randomUUID()+"---";
saveTime(savedTimes, startTime);
}
System.out.println("Created string of length:"+str.length()+" in "+(System.currentTimeMillis()-startTimeAll)+" ms");
}
static void case3() {
List<Long> savedTimes = new ArrayList();
long startTimeAll = System.currentTimeMillis();
StringBuilder str = new StringBuilder("");
for (int i = 0; i < MAX_ITERATIONS; i++) {
long startTime = System.currentTimeMillis();
str.append(UUID.randomUUID()+"---");
saveTime(savedTimes, startTime);
}
System.out.println("Created string of length:"+str.length()+" in "+(System.currentTimeMillis()-startTimeAll)+" ms");
}
static void saveTime(List<Long> executionTimes, long startTime) {
executionTimes.add(System.currentTimeMillis()-startTime);
if(executionTimes.size()%CALC_AVG_EVERY == 0) {
out.println("average time for "+executionTimes.size()+" concatenations: "+
NumberFormat.getInstance().format(executionTimes.stream().mapToLong(Long::longValue).average().orElseGet(()->0))+
" ms avg");
executionTimes.clear();
}
}
输出:
10000 次串联的平均时间:平均 0.096 毫秒
10000 次串联的平均时间:平均 0.185 毫秒
10000 次串联的平均时间:平均 0.327 毫秒
10000 次串联的平均时间:平均 0.501 毫秒
10000 次串联的平均时间:平均 0.656 毫秒
创建长度为 1950000 的字符串 17745 毫秒
10000 次串联的平均时间:平均 0.21 毫秒
10000 次串联的平均时间:平均 0.652 毫秒
10000 次串联的平均时间:平均 1.129 毫秒
10000 次串联的平均时间:平均 1.727 毫秒
10000 次串联的平均时间:平均 2.302 毫秒
创建长度为 1950000 的字符串 60279 毫秒
10000 次串联的平均时间:平均 0.002 毫秒
10000 次串联的平均时间:平均 0.002 毫秒
10000 次串联的平均时间:平均 0.002 毫秒
10000 次串联的平均时间:平均 0.002 毫秒
10000 次串联的平均时间:平均 0.002 毫秒
创建长度为 1950000 的字符串 100毫秒
随着字符串长度的增加,连接时间也会增加。
那就是 StringBuilder
绝对需要。
如您所见,串联: UUID.randomUUID()+"---"
, ,并没有真正影响时间。
附: 我不认为 何时在 Java 中使用 StringBuilder 确实是这个的重复。
这个问题谈到 toString()
大多数时候不执行大字符串的串联。
在性能方面,使用“+”进行字符串连接的成本更高,因为它必须创建一个全新的字符串副本,因为字符串在 java 中是不可变的。如果串联非常频繁,这会发挥特别的作用,例如:在一个循环内。以下是当我尝试做这样的事情时我的想法建议:
一般规则:
- 在单个字符串赋值中,使用字符串连接就可以了。
- 如果您要循环构建大量字符数据,请选择 StringBuffer。
- 在 String 上使用 += 总是比使用 StringBuffer 效率低,因此应该敲响警钟 - 但在某些情况下,与可读性问题相比,获得的优化可以忽略不计,因此请使用常识。
这里有一个 不错的乔恩·斯基特博客 围绕这个话题。
我可以指出,如果您要迭代集合并使用 StringBuilder,您可能需要查看 阿帕奇通用语言 和 StringUtils.join() (不同口味)?
无论性能如何,它都会让您不必创建 StringBuilder 和 for 循环,以实现看起来像 百万分之一 时间。
我比较了四种不同的方法来比较性能。我完全不知道 gc 会发生什么,但对我来说重要的是时间。编译器是这里很重要的因素。我在window8.1平台下使用jdk1.8.0_45。
concatWithPlusOperator = 8
concatWithBuilder = 130
concatWithConcat = 127
concatStringFormat = 3737
concatWithBuilder2 = 46
public class StringConcatenationBenchmark {
private static final int MAX_LOOP_COUNT = 1000000;
public static void main(String[] args) {
int loopCount = 0;
long t1 = System.currentTimeMillis();
while (loopCount < MAX_LOOP_COUNT) {
concatWithPlusOperator();
loopCount++;
}
long t2 = System.currentTimeMillis();
System.out.println("concatWithPlusOperator = " + (t2 - t1));
long t3 = System.currentTimeMillis();
loopCount = 0;
while (loopCount < MAX_LOOP_COUNT) {
concatWithBuilder();
loopCount++;
}
long t4 = System.currentTimeMillis();
System.out.println("concatWithBuilder = " + (t4 - t3));
long t5 = System.currentTimeMillis();
loopCount = 0;
while (loopCount < MAX_LOOP_COUNT) {
concatWithConcat();
loopCount++;
}
long t6 = System.currentTimeMillis();
System.out.println("concatWithConcat = " + (t6 - t5));
long t7 = System.currentTimeMillis();
loopCount = 0;
while (loopCount < MAX_LOOP_COUNT) {
concatStringFormat();
loopCount++;
}
long t8 = System.currentTimeMillis();
System.out.println("concatStringFormat = " + (t8 - t7));
long t9 = System.currentTimeMillis();
loopCount = 0;
while (loopCount < MAX_LOOP_COUNT) {
concatWithBuilder2();
loopCount++;
}
long t10 = System.currentTimeMillis();
System.out.println("concatWithBuilder2 = " + (t10 - t9));
}
private static void concatStringFormat() {
String s = String.format("%s %s %s %s ", "String", "String", "String", "String");
}
private static void concatWithConcat() {
String s = "String".concat("String").concat("String").concat("String");
}
private static void concatWithBuilder() {
StringBuilder builder=new StringBuilder("String");
builder.append("String").append("String").append("String");
String s = builder.toString();
}
private static void concatWithBuilder2() {
String s = new StringBuilder("String").append("String").append("String").append("String").toString();
}
private static void concatWithPlusOperator() {
String s = "String" + "String" + "String" + "String";
}
}
这是我在Java8中检查的内容
- 使用字符串连接
使用字符串生成器
long time1 = System.currentTimeMillis(); usingStringConcatenation(100000); System.out.println("usingStringConcatenation " + (System.currentTimeMillis() - time1) + " ms"); time1 = System.currentTimeMillis(); usingStringBuilder(100000); System.out.println("usingStringBuilder " + (System.currentTimeMillis() - time1) + " ms"); private static void usingStringBuilder(int n) { StringBuilder str = new StringBuilder(); for(int i=0;i<n;i++) str.append("myBigString"); } private static void usingStringConcatenation(int n) { String str = ""; for(int i=0;i<n;i++) str+="myBigString"; }
如果您对大量字符串使用字符串连接,那真是一场噩梦。
usingStringConcatenation 29321 ms
usingStringBuilder 2 ms
我认为我们应该采用 StringBuilder 附加方法。原因是
String 连接每次都会创建一个新的字符串对象(由于 String 是不可变对象),因此会创建 3 个对象。
使用字符串生成器,只会创建一个对象[StringBuilder 是可变的],并且将进一步的字符串附加到它。
对于像这样的简单字符串,我更喜欢使用
"string".concat("string").concat("string");
按照顺序,我想说构造字符串的首选方法是使用 StringBuilder、String#concat(),然后是重载的 + 运算符。当处理大型字符串时,StringBuilder 会显着提高性能,就像使用 + 运算符会导致性能大幅下降(随着字符串大小的增加,性能呈指数级大幅下降)。使用 .concat() 的一个问题是它可能会抛出 NullPointerExceptions。