blocks|key|1549644|text|其中一个不应该比另一个快。在Java1.4.2之前就不是这样了，因为当使用"%2B“操作符连接两个以上的字符串时，在构建最终字符串的过程中会创建中间的String对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1549645|然而，正如JavaDoc+for+StringBuffer声明的那样，至少从Java1.4.2开始，使用"%2B“运算符编译为创建一个StringBuffer并将许多字符串append()到它。因此，显然没有区别。|1549646|但是，在循环中使用将字符串添加到另一个字符串时要小心！例如：|1549647|String+myString+=+"";

for+(String+s+:+listOfStrings)+{
++//+Be+careful!+You're+creating+one+intermediate+String+object
++//+for+every+iteration+on+the+list+(this+is+costly!)
++myString+%2B=+s;
}|code-block|syntax|javascript|1549648|但是，请记住，通常将几个字符串与"%2B“连接起来要比将它们全部用append()连接起来要干净。|1549649|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.4.2/docs/api/java/lang/StringBuffer.html^0|21|6|0|1T|C|2C|8|5|O|0|0|0|0|V|8|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|H|3|I|5|6|7|19|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1A|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

One shouldn't be faster than the other. This wasn't true before Java 1.4.2, because when concatenating more than two strings using the "+" operator, intermediate <code>String</code> objects would be created during the process of building the final string.

However, as the <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/StringBuffer.html" rel="noreferrer">JavaDoc for StringBuffer</a> states, at least since Java 1.4.2 using the "+" operator compiles down to creating a <code>StringBuffer</code> and <code>append()</code>ing the many strings to it. So no difference, apparently.

However, be careful when using adding a string to another inside a loop! For example:

<pre><code>String myString = "";

for (String s : listOfStrings) {
 // Be careful! You're creating one intermediate String object
 // for every iteration on the list (this is costly!)
 myString += s;
}
</code></pre>

Keep in mind, however, that usually concatenating a few strings with "+" is cleaner than <code>append()</code>ing them all.

blocks|key|1549715|text|在幕后，它实际创建并附加到一个StringBuffer，对结果调用toString()。所以实际上你使用哪一个已经不重要了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1549716|所以|1549717|String+s+=+"a"+%2B+"b"+%2B+"c";|code-block|syntax|javascript|1549718|变成了|1549719|String+s+=+new+StringBuffer().append("a").append("b").append("c").toString();|1549720|这对于一条语句中的一堆内联追加来说是正确的。如果在使用多个语句的过程中构建字符串，则是在浪费内存，StringBuffer或StringBuilder是更好的选择。|1549721|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Under the hood, it actually creates and appends to a StringBuffer, calling toString() on the result. So it actually doesn't matter which you use anymore.

So 

<pre><code>String s = "a" + "b" + "c";
</code></pre>

becomes

<pre><code>String s = new StringBuffer().append("a").append("b").append("c").toString();
</code></pre>

That's true for a bunch of inlined appends within a single statement. If you build your string over the course of multiple statements, then you're wasting memory and a StringBuffer or StringBuilder is your better choice.

blocks|key|1549784|text|因为字符串在Java中是不可修改的，所以每次连接一个字符串时，都会在内存中创建新的对象。SpringBuffer在内存中使用相同的对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1549785|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|$]]

Because Strings are imutable in Java, every time you concanate a String, new object is created in memory. SpringBuffer use the same object in memory.

blocks|key|1764828|text|要使用'%2B‘连接两个字符串，需要为两个字符串分配一个新的字符串空间，然后从两个字符串复制数据。StringBuffer针对串联进行了优化，并分配了比最初所需更多的空间。在大多数情况下，连接新字符串时，可以简单地将字符复制到现有字符串缓冲区的末尾。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1764829|对于连接两个字符串，'%2B‘运算符可能会有较少的开销，但当您连接更多字符串时，StringBuffer将领先，使用更少的内存分配和更少的数据复制。|1764830|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

To concatenate two strings using '+', a new string needs to be allocated with space for both strings, and then the data copied over from both strings. A StringBuffer is optimized for concatenating, and allocates more space than needed initially. When you concatenate a new string, in most cases, the characters can simply be copied to the end of the existing string buffer. 
For concatenating two strings, the '+' operator will probably have less overhead, but as you concatenate more strings, the StringBuffer will come out ahead, using fewer memory allocations, and less copying of data.

blocks|key|1549918|text|最好使用StringBuilder+(它是一个非同步版本；什么时候可以并行构建字符串？)如今，几乎在每种情况下，都是这样的，但下面是发生的情况：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1549919|将%2B与两个字符串一起使用时，它会编译如下代码：|1549920|String+third+=+first+%2B+second;|code-block|syntax|javascript|1549921|类似这样的东西：|1549922|StringBuilder+builder+=+new+StringBuilder(+first+);
builder.append(+second+);
third+=+builder.toString();|1549923|因此，对于一些小的例子来说，这通常不会有什么不同。但是当你构建一个复杂的字符串时，你通常需要处理比这更多的事情；例如，你可能要使用许多不同的附加语句，或者像下面这样的循环：|1549924|for(+String+str+:+strings+)+{
++out+%2B=+str;
}|1549925|在这种情况下，在每次迭代中都需要一个新的StringBuilder实例和一个新的String+(+out+-String的新值是不可变的)。这是非常浪费的。将其替换为单个StringBuilder意味着您可以只生成单个String，而不会用您不关心的String来填满堆。|offset|length|style|CODE|1549926|entityMap^0|0|0|0|0|0|0|0|K|D|14|6|1D|3|1I|6|2D|D|31|6|3H|6|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|15|8|@$S|16|T|17|U|V]|$S|18|T|19|U|V]|$S|1A|T|1B|U|V]|$S|1C|T|1D|U|V]|$S|1E|T|1F|U|V]|$S|1G|T|1H|U|V]|$S|1I|T|1J|U|V]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|X|$]]

It's better to use StringBuilder (it's an unsynchronized version; when do you build strings in parallel?) these days, in almost every case, but here's what happens:

When you use + with two strings, it compiles code like this:

<pre><code>String third = first + second;
</code></pre>

To something like this:

<pre><code>StringBuilder builder = new StringBuilder( first );
builder.append( second );
third = builder.toString();
</code></pre>

Therefore for just little examples, it usually doesn't make a difference. But when you're building a complex string, you've often got a lot more to deal with than this; for example, you might be using many different appending statements, or a loop like this:

<pre><code>for( String str : strings ) {
 out += str;
}
</code></pre>

In this case, a new <code>StringBuilder</code> instance, and a new <code>String</code> (the new value of <code>out</code> - <code>String</code>s are immutable) is required in each iteration. This is very wasteful. Replacing this with a single <code>StringBuilder</code> means you can just produce a single <code>String</code> and not fill up the heap with <code>String</code>s you don't care about.

blocks|key|1764949|text|StringBuffer类维护一个字符数组来保存您连接的字符串的内容，而%2B方法在每次调用它时都会创建一个新字符串，并附加两个参数(param1+%2B+param2)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1764950|StringBuffer更快，因为1.它可能能够使用它已经存在的数组来连接/存储所有字符串。2.即使它们不适合数组，分配一个更大的后备数组也比为每次调用生成新的String对象更快。|1764951|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The StringBuffer class maintains an array of characters to hold the contents of the strings you concatenate, whereas the + method creates a new string each time its called and appends the two parameters (param1 + param2).

The StringBuffer is faster because 1. it might be able to use its already existing array to concat/store all of the strings. 2. even if they don't fit in the array, its faster to allocate a larger backing array then to generate new String objects for each evocation.

blocks|key|1765005|text|我认为考虑到jdk1.5+(或更高版本)和你的连接是线程安全的，你应该使用StringBuilder而不是StringBuffer+http://java4ever.blogspot.com/2007/03/string-vs-stringbuffer-vs-stringbuilder.html来提高速度：http://www.about280.com/stringtest.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1765006|就我个人而言，我编写代码的目的是为了提高可读性，所以除非您发现字符串连接会使您的代码变得相当慢，否则请使用任何使您的代码更具可读性的方法。|1765007|entityMap|0|LINK|mutability|MUTABLE|url|http://java4ever.blogspot.com/2007/03/string-vs-stringbuffer-vs-stringbuilder.html|1|http://www.about280.com/stringtest.html^0|1U|2A|0|4A|13|1|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

I think that given jdk1.5 (or greater) and your concatenation is thread-safe you should use StringBuilder instead of StringBuffer
<a href="http://java4ever.blogspot.com/2007/03/string-vs-stringbuffer-vs-stringbuilder.html" rel="noreferrer">http://java4ever.blogspot.com/2007/03/string-vs-stringbuffer-vs-stringbuilder.html</a>
As for the gains in speed:
<a href="http://www.about280.com/stringtest.html" rel="noreferrer">http://www.about280.com/stringtest.html</a>

Personally I'd code for readability, so unless you find that string concatenation makes your code considerably slower, stay with whichever method makes your code more readable.

blocks|key|1765045|text|我认为最简单的答案是:它更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1765046|如果你真的想知道所有底层的东西，你可以自己看看源代码：|1765047|http://www.sun.com/software/opensource/java/getinvolved.jsp|offset|length|1765048|http://download.java.net/jdk6/latest/archive/|1765049|entityMap|0|LINK|mutability|MUTABLE|url|1^0|0|0|0|1N|0|0|0|19|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$F|U|G|V|1|W]]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@$F|Y|G|Z|1|10]]|A|$]]|$1|J|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|E]]|Q|$5|M|N|O|A|$P|I]]]]

I think the simplest answer is: it's faster.

If you really want to know all the under-the-hood stuff, you could always have a look at the source yourself:

<a href="http://www.sun.com/software/opensource/java/getinvolved.jsp" rel="nofollow noreferrer">http://www.sun.com/software/opensource/java/getinvolved.jsp</a>

<a href="http://download.java.net/jdk6/latest/archive/" rel="nofollow noreferrer">http://download.java.net/jdk6/latest/archive/</a>

blocks|key|1550133|text|Java+Language+Specification的String+Concatenation+Operator+%2B一节提供了更多关于%2B运算符为什么会如此慢的背景信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1550134|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.18.1^0|S|V|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

The section <a href="http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.18.1" rel="nofollow noreferrer">String Concatenation Operator +</a> of the Java Language Specification gives you some more background information on why the + operator can be so slow.

blocks|key|1550205|text|当您连接两个字符串时，实际上在Java中创建了第三个String对象。使用StringBuffer+(或Java5/6中的StringBuilder+)更快，因为它使用内部字符数组来存储字符串，并且当您使用它的add(...)方法时，它不会创建新的String对象。相反，StringBuffer/Buider会追加内部数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1550206|在简单的连接中，使用StringBuffer/Builder或'%2B‘运算符连接字符串并不是问题，但在进行大量字符串连接时，您会发现使用StringBuffer/Builder要快得多。|1550207|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

When you concatenate two strings, you actually create a third String object in Java. Using StringBuffer (or StringBuilder in Java 5/6), is faster because it uses an internal array of chars to store the string, and when you use one of its add(...) methods, it doesn't create a new String object. Instead, StringBuffer/Buider appends the internal array.

In simple concatenations, it's not really an issue whether you concatenate strings using StringBuffer/Builder or the '+' operator, but when doing a lot of string concatenations, you'll see that using a StringBuffer/Builder is way faster.

blocks|key|1765309|text|它取决于JVM的版本，在1.5之前的版本中，使用"%2B“或"%2B=”实际上每次都复制了整个字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1765310|注意，使用%2B=实际上会分配字符串的新副本。|1765311|正如前面所指出的，使用%2B+in循环涉及到复制。|1765312|当被压缩的字符串是在编译时连接在一起的编译时常量，则|1765313|String+foo+=+"a"+%2B+"b"+%2B+"c";|code-block|syntax|javascript|1765314|Has被编译为：|1765315|String+foo+=+"abc";+|1765316|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

AFAIK it depends on version of JVM, in versions prior to 1.5 using "+" or "+=" actually copied the whole string every time. 

Beware that using += actually allocates the new copy of string. 

As was pointed using + in loops involves copying. 

When strings that are conactenated are compile time constants there concatenated at compile time, so 

<pre><code>String foo = "a" + "b" + "c";
</code></pre>

Has is compiled to:

<pre><code>String foo = "abc"; 
</code></pre>

blocks|key|1550369|text|更多信息：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1550370|StringBuffer是一个线程安全类|1550371|public+final+class+StringBuffer+extends+AbstractStringBuilder
++++implements+Serializable,+CharSequence
{
//+..+skip+..
+++++public+synchronized+StringBuffer+append(StringBuffer+stringbuffer)
++++{
++++++++super.append(stringbuffer);
++++++++return+this;
++++}
//+..+skip+..
}|code-block|syntax|javascript|1550372|但是StringBuilder不是线程安全的，因此如果可能的话，使用StringBuilder会更快|1550373|public+final+class+StringBuilder+extends+AbstractStringBuilder
++++implements+Serializable,+CharSequence
{
//+..+skip+..
++++public+StringBuilder+append(String+s)
++++{
++++++++super.append(s);
++++++++return+this;
++++}
//+..+skip+..
}|1550374|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Further information:

StringBuffer is a thread-safe class

<pre><code>
public final class StringBuffer extends AbstractStringBuilder
 implements Serializable, CharSequence
{
// .. skip ..
 public synchronized StringBuffer append(StringBuffer stringbuffer)
 {
 super.append(stringbuffer);
 return this;
 }
// .. skip ..
}
</code></pre>

But StringBuilder is not thread-safe, thus it is faster to use StringBuilder if possible

<pre><code>
public final class StringBuilder extends AbstractStringBuilder
 implements Serializable, CharSequence
{
// .. skip ..
 public StringBuilder append(String s)
 {
 super.append(s);
 return this;
 }
// .. skip ..
}

</code></pre>

Someone told me it's more efficient to use <code>StringBuffer</code> to concatenate strings in Java than to use the <code>+</code> operator for <code>String</code>s. What happens under the hood when you do that? What does <code>StringBuffer</code> do differently?

Why to use StringBuffer in Java instead of the string concatenation operator

Java

有人告诉我，在java语言中使用StringBuffer连接字符串比使用+操作符连接String更有效，当你这么做的时候会发生什么？StringBuffer有什么不同之处？

问为什么在Java中使用StringBuffer而不是字符串连接运算符
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在Java中使用StringBuffer而不是字符串连接运算符EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在Java中使用StringBuffer而不是字符串连接运算符
EN