blocks|key|827122|text|Microsoft认证材料解决了同样的问题。在.NET世界中，StringBuilder对象的开销使2个String对象的简单连接更有效。我假设Java字符串也有类似的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827123|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|$]]

The Microsoft certification material addresses this same question. In the .NET world, the overhead for the StringBuilder object makes a simple concatenation of 2 String objects more efficient. I would assume a similar answer for Java strings.

blocks|key|1042003|text|看看：http://www.javaspecialists.eu/archive/Issue068.html和http://www.javaspecialists.eu/archive/Issue105.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1042004|在您的环境中执行相同的测试，并检查较新的JDK或您的Java实现是否在String或StringBuilder中更好地执行某种类型的字符串操作。|style|CODE|1042005|entityMap|0|LINK|mutability|MUTABLE|url|http://www.javaspecialists.eu/archive/Issue068.html|1|http://www.javaspecialists.eu/archive/Issue105.html^0|3|1F|0|1J|1F|1|0|Z|6|16|D|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@$A|Z|B|10|F|G]|$A|11|B|12|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]]]

Have a look at: <a href="http://www.javaspecialists.eu/archive/Issue068.html" rel="nofollow">http://www.javaspecialists.eu/archive/Issue068.html</a> and <a href="http://www.javaspecialists.eu/archive/Issue105.html" rel="nofollow">http://www.javaspecialists.eu/archive/Issue105.html</a>

Do the same tests in your environment and check if newer JDK or your Java implementation do some type of string operation better with <code>String</code> or better with <code>StringBuilder</code>.

blocks|key|827494|text|一般来说，总是使用可读性更好的代码，只有在性能有问题的情况下才进行重构。在这种特定情况下，大多数最新的JDK实际上在任何情况下都会将代码优化为StringBuilder版本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827495|如果您在循环中或在编译器无法轻松优化的一些复杂代码中进行字符串连接，则通常只需要手动执行此操作。|827496|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|$]]

As a general rule, always use the more readable code and only refactor if performance is an issue. In this specific case, most recent JDK's will actually optimize the code into the StringBuilder version in any case. 

You usually only really need to do it manually if you are doing string concatenation in a loop or in some complex code that the compiler can't easily optimize.

blocks|key|827571|text|字符串连接的问题是，它会导致复制字符串对象以及所有相关的成本。StringBuilder不是线程安全的，因此比Java5之前的首选StringBuffer更快。根据经验，您不应该在循环中进行字符串连接，这将经常被调用。我猜在这里和那里做一些连接不会对您造成伤害，只要您不是在谈论数百个，这当然取决于您的性能要求。如果你正在做实时的事情，你应该非常小心。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827572|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|$]]

The problem with String concatenation is that it leads to copying of the String object with all the associated cost. StringBuilder is not threadsafe and is therefore faster than StringBuffer, which used to be the preferred choice before Java 5. As a rule of thumb, you should not do String concatenation in a loop, which will be called often. I guess doing a few concatenations here and there will not hurt you as long as you are not talking about hundreds and this of course depends on your performance requirements. If you are doing real time stuff, you should be very careful.

blocks|key|1042511|text|%2B运算符在内部使用public+String+concat(String+str)。此方法复制两个字符串的字符，因此它具有与两个字符串的长度成比例的内存需求和运行时复杂性。StringBuilder的效率更高。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1042512|然而，我在here上读到，在post+Java4编译器上，使用%2B运算符的连接代码被更改为StringBuilder。所以这可能根本不是问题。(尽管如果我在代码中依赖这个语句，我真的会检查它！)|1042513|entityMap|0|LINK|mutability|MUTABLE|url|http://www.coderanch.com/t/203045/Performance/java/Performance-Impact-String-vs-StringBuilder^0|9|W|0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@$9|T|A|U|1|V]]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

The + operator uses <code>public String concat(String str)</code> internally. This method copies the characters of the two strings, so it has memory requirements and runtime complexity proportional to the length of the two strings. StringBuilder works more efficent.

However I have read <a href="http://www.coderanch.com/t/203045/Performance/java/Performance-Impact-String-vs-StringBuilder" rel="nofollow">here</a> that the concatination code using the + operater is changed to StringBuilder on post Java 4 compilers. So this might not be an issue at all. (Though I would really check this statement if I depend on it in my code!)

blocks|key|827715|text|如果您在循环中使用字符串连接，如下所示，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827716|String+s+=+"";
for+(int+i+=+0;+i+<+100;+i%2B%2B)+{
++++s+%2B=+",+"+%2B+i;
}|code-block|syntax|javascript|827717|然后，您应该使用StringBuilder+(而不是StringBuffer)而不是String，因为它更快且消耗更少的内存。|offset|length|style|CODE|827718|如果您只有一条语句，|827719|String+s+=+"1,+"+%2B+"2,+"+%2B+"3,+"+%2B+"4,+"+...;|827720|因为编译器将自动使用StringBuilder，所以您可以使用Strings。|827721|entityMap^0|0|0|8|D|Q|C|16|6|0|0|0|A|D|V|6|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|15|8|@$I|16|J|17|K|L]|$I|18|J|19|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$]]

If you use String concatenation in a loop, something like this,

<pre><code>String s = "";
for (int i = 0; i &lt; 100; i++) {
 s += ", " + i;
}
</code></pre>

then you should use a <code>StringBuilder</code> (not <code>StringBuffer</code>) instead of a <code>String</code>, because it is much faster and consumes less memory.

If you have a single statement,

<pre><code>String s = "1, " + "2, " + "3, " + "4, " ...;
</code></pre>

then you can use <code>String</code>s, because the compiler will use <code>StringBuilder</code> automatically.

blocks|key|827762|text|拉尔夫的回答很棒。我更喜欢使用StringBuilder类来构建/修饰字符串，因为它的用法更像是生成器模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827763|public+String+decorateTheString(String+orgStr){
++++++++++++StringBuilder+builder+=+new+StringBuilder();
++++++++++++builder.append(orgStr);
++++++++++++builder.deleteCharAt(orgStr.length()-1);
++++++++++++builder.insert(0,builder.hashCode());
++++++++++++return+builder.toString();
}|code-block|syntax|javascript|827764|它可以用作构建字符串的帮助器/构建器，而不是字符串本身。|827765|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Ralph's answer is fabulous. I would rather use StringBuilder class to build/decorate the String because the usage of it is more look like Builder pattern.

<pre><code>public String decorateTheString(String orgStr){
 StringBuilder builder = new StringBuilder();
 builder.append(orgStr);
 builder.deleteCharAt(orgStr.length()-1);
 builder.insert(0,builder.hashCode());
 return builder.toString();
}
</code></pre>

It can be use as a helper/builder to build the String, not the String itself.

blocks|key|1042657|text|对于两个字符串连接更快，在其他情况下StringBuilder是更好的选择，请参阅我在concatenation+operator+(%2B)+vs+concat()中的解释|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1042658|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/8755063/concatenation-operator-vs-concat/13739225#13739225^0|17|12|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]]]]

For two strings concat is faster, in other cases StringBuilder is a better choice, see my explanation in <a href="https://stackoverflow.com/questions/8755063/concatenation-operator-vs-concat/13739225#13739225">concatenation operator (+) vs concat()</a>

blocks|key|1042701|text|某些编译器可能不会将任何字符串连接替换为StringBuilder等效项。在依赖编译时优化之前，一定要考虑源代码将使用哪些编译器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1042702|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|$]]

Some compilers may not replace any string concatenations with StringBuilder equivalents. Be sure to consider which compilers your source will use before relying on compile time optimizations.

It is supposed to be generally preferable to use a <code>StringBuilder</code> for string concatenation in Java. Is this always the case?

What I mean is this: Is the overhead of creating a <code>StringBuilder</code> object, calling the <code>append()</code> method and finally <code>toString()</code> already smaller then concatenating existing strings with the <code>+</code> operator for two strings, or is it only advisable for more (than two) strings?

If there is such a threshold, what does it depend on (perhaps the string length, but in which way)?

And finally, would you trade the readability and conciseness of the <code>+</code> concatenation for the performance of the <code>StringBuilder</code> in smaller cases like two, three or four strings?

Explicit use of <code>StringBuilder</code> for regular concatenations is being mentioned as obsolete at <a href="https://stackoverflow.com/questions/4019180/obsolete-java-optimization-tips">obsolete Java optimization tips</a> as well as at <a href="https://stackoverflow.com/questions/2248278/java-urban-myths">Java urban myths</a>.

When to use StringBuilder in Java

编译器

Java

一般认为，在Java语言中使用StringBuilder进行字符串连接是更可取的。一直都是这样吗？我的意思是:创建一个StringBuilder对象，调用append()方法，最后toString()的开销是否已经比将现有字符串与两个字符串的+操作符连接在一起的开销更小，还是只对(两个以上)字符串是可取的？如果有这样的...

问何时在Java中使用StringBuilder
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问何时在Java中使用StringBuilderEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问何时在Java中使用StringBuilder
EN