blocks|key|1088871|text|StringBuffer用于从多个字符串创建单个字符串，例如，当您想要在循环中附加字符串的部分时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1088872|当只有一个线程访问StringBuffer时，您应该使用StringBuilder而不是StringBuffer，因为StringBuilder不是同步的，因此速度更快。|1088873|AFAIK在作为一种语言的Java中，字符串大小没有上限，但JVM可能有上限。|1088874|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|$]]

A StringBuffer is used to create a single string from many strings, e.g. when you want to append parts of a String in a loop.

You should use a StringBuilder instead of a StringBuffer when you have only a single Thread accessing the StringBuffer, since the StringBuilder is not synchronized and thus faster.

AFAIK there is no upper limit for String size in Java as a language, but the JVMs probably have an upper limit.

blocks|key|1304163|text|String是一个不可变的字符数组。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1304164|StringBuffer是一个可变的字符数组。通常在完成变异后转换回String。|1304165|由于两者都是数组，因此两者的最大大小都等于整数的最大大小，即2%5E31-1+(请参阅JavaDoc，同时查看String和StringBuffer的JavaDoc+).This是因为数组的.length参数是原语int。(参见Arrays)。|1304166|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Integer.html#MAX_VALUE|1|http://java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html^0|0|6|0|0|C|Y|6|0|1H|6|1O|C|2L|7|2X|3|15|7|0|34|6|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@$9|1A|A|1B|1|1C]|$9|1D|A|1E|1|1F]]|E|$]]|$1|J|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

A <code>String</code> is an immutable character array.

A <code>StringBuffer</code> is a mutable character array. Often converted back to <code>String</code> when done mutating.

Since both are an array, the maximum size for both is equal to the maximum size of an integer, which is 2^31-1 (see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Integer.html#MAX_VALUE" rel="nofollow noreferrer">JavaDoc</a>, also check out the JavaDoc for both <code>String</code> and <code>StringBuffer</code>).This is because the <code>.length</code> argument of an array is a primitive <code>int</code>. (See <a href="http://java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html" rel="nofollow noreferrer">Arrays</a>).

blocks|key|1304225|text|String是不可变的，这意味着当您在String上执行操作时，您实际上是在创建一个全新的String。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1304226|StringBuffer是可变的，您可以追加到它后面，也可以将它的长度重置为0。|offset|length|1304227|在实践中，编译器似乎在字符串连接for+performance+reasons期间使用StringBuffer。|1304228|entityMap|0|LINK|mutability|MUTABLE|url|http://download.oracle.com/javase/6/docs/api/java/lang/StringBuffer.html|1|http://intgat.tigress.co.uk/rmy/jopt/opt7.html^0|0|0|C|0|0|G|N|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

String is immutable, meaning that when you perform an operation on a String you are really creating a whole new String.

<a href="http://download.oracle.com/javase/6/docs/api/java/lang/StringBuffer.html" rel="nofollow">StringBuffer</a> is mutable, and you can append to it as well as reset its length to 0.

In practice, the compiler seems to use StringBuffer during String concatenation <a href="http://intgat.tigress.co.uk/rmy/jopt/opt7.html" rel="nofollow">for performance reasons</a>.

blocks|key|1089016|text|String是一个不可变的类。这意味着一旦你像这样实例化了一个字符串的实例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089017|String+str1+=+"hello";|code-block|syntax|javascript|1089018|内存中的对象不能更改。相反，您必须创建一个新的实例，复制旧的字符串并附加任何其他内容，如本例所示：|1089019|String+str1+=+"hello";
str1+=+str1+%2B+"+world!";|1089020|实际发生的情况是，我们没有更新现有的str1对象...我们一起重新分配新的内存，复制"hello“数据并附加”world!“最后，将str1引用设置为指向这个新内存。因此，它看起来更像是这样的：|1089021|String+str1+=+"hello";
String+str2+=+str1+%2B+"+world!";
str1+=+str2;|1089022|因此，这个“复制%2B粘贴并在内存中到处移动东西”的过程如果重复地完成，特别是递归地完成，可能会非常昂贵。|1089023|当您处于不得不一遍又一遍地做事情的情况下，请使用StringBuilder。它是可变的，可以将字符串附加到当前字符串的末尾，因为它是由growing+array返回的。|offset|length|1089024|entityMap|0|LINK|mutability|MUTABLE|url|not+100%25+if+that+is+the+actual+data+structure,+could+be+a+list^0|0|0|0|0|0|0|0|1V|D|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@$S|1A|T|1B|1|1C]]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

String is an immutable class. This means that once you instantiate an instance of a string like so:

<pre><code>String str1 = "hello";
</code></pre>

The object in memory cannot be altered. Instead you will have to create a new instance, copy the old String and append whatever else as in this example:

<pre><code>String str1 = "hello";
str1 = str1 + " world!";
</code></pre>

What is really happening hear is that we are NOT updating the existing str1 object... we are reallocating new memory all together, copying the "hello" data and appending " world!" to the end, then settings the str1 reference to point to this new memory. So it really looks more like this under the hood:

<pre><code>String str1 = "hello";
String str2 = str1 + " world!";
str1 = str2;
</code></pre>

So it follows that this "copy + paste and move stuff around in memory" process can be very expensive if done repitively especially recursively.

When you are in that situation of having to do things over and over utilize StringBuilder. It is mutable and can append strings to the end of the current one because it's back by an [growing array] (not 100% if that is the actual data structure, could be a list).

blocks|key|1304285|text|String++++++++++++++++++++++++++++++++++++++++++StringBuffer

Immutable+++++++++++++++++++++++++++++++++++++++Mutable
String+s=new+String("karthik");++++++++++++++++StringBuffer+sb=new+StringBuffer("karthik")
s.concat("reddy");+++++++++++++++++++++++++++++sb.append("reddy");
System.out.println(s);+++++++++++++++++++++++++System.out.println(sb);
O/P:karthik++++++++++++++++++++++++++++++++++++O/P:karthikreddy

--->once+we+created+a+String+object++++++++++++---->once+we+created+a+StringBuffer+object
we+can't+perform+any+changes+in+the+existing++we+can+perform+any+changes+in+the+existing
object.If+we+are+trying+to+perform+any++++++++object.It+is+nothing+but+mutablity+of+
changes+with+those+changes+a+new+object+++++++of+a+StrongBuffer+object
will+be+created.It+is+nothing+but+Immutability
of+a+String+object

Use+String--->If+you+require+immutabilty
Use+StringBuffer---->If+you+require+mutable+%2B+threadsafety
Use+StringBuilder--->If+you+require+mutable+%2B+with+out+threadsafety

String+s=new+String("karthik");
--->here+2+objects+will+be+created+one+is+heap+and+the+other+is+in+stringconstantpool(scp)+and+s+is+always+pointing+to+heap+object

String+s="karthik";+
--->In+this+case+only+one+object+will+be+created+in+scp+and+s+is+always+pointing+to+that+object+only|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1304286|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>String StringBuffer

Immutable Mutable
String s=new String("karthik"); StringBuffer sb=new StringBuffer("karthik")
s.concat("reddy"); sb.append("reddy");
System.out.println(s); System.out.println(sb);
O/P:karthik O/P:karthikreddy

---&gt;once we created a String object ----&gt;once we created a StringBuffer object
we can't perform any changes in the existing we can perform any changes in the existing
object.If we are trying to perform any object.It is nothing but mutablity of 
changes with those changes a new object of a StrongBuffer object
will be created.It is nothing but Immutability
of a String object

Use String---&gt;If you require immutabilty
Use StringBuffer----&gt;If you require mutable + threadsafety
Use StringBuilder---&gt;If you require mutable + with out threadsafety

String s=new String("karthik");
---&gt;here 2 objects will be created one is heap and the other is in stringconstantpool(scp) and s is always pointing to heap object

String s="karthik"; 
---&gt;In this case only one object will be created in scp and s is always pointing to that object only
</code></pre>

blocks|key|1089077|text|String+is+immutable.+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1089078|为什么？检查here。|unstyled|offset|length|1089079|StringBuffer+is+not.+It+is+thread+safe.+|1089080|更多的问题，比如什么时候使用，以及其他概念可以在this之后解决。|1089081|希望这能有所帮助。|1089082|entityMap|0|LINK|mutability|MUTABLE|url|http://www.acquireandinspire.org/2013/01/why-is-string-made-immutable.html|1|http://www.acquireandinspire.org/2013/01/string-string-builder-string-buffer.html^0|0|6|4|0|0|0|O|4|1|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Z|8|@]|9|@$G|10|H|11|1|12]]|A|$]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$B|C]]|$1|K|3|L|5|F|7|14|8|@]|9|@$G|15|H|16|1|17]]|A|$]]|$1|M|3|N|5|F|7|18|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

<pre><code>String is immutable. 
</code></pre>

Why? Check <a href="http://www.acquireandinspire.org/2013/01/why-is-string-made-immutable.html" rel="nofollow">here</a>.

<pre><code>StringBuffer is not. It is thread safe. 
</code></pre>

Further questions like when to use which and other concepts can be figured out following <a href="http://www.acquireandinspire.org/2013/01/string-string-builder-string-buffer.html" rel="nofollow">this</a>.

Hope this helps.

blocks|key|1089105|text|通过在任何追加操作后打印String/StringBuffer对象的哈希码，也证明了每次都会在内部使用新值重新创建String对象，而不是使用相同的String对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1089106|public+class+MutableImmutable+{

/**
+*+@param+args
+*/
public+static+void+main(String[]+args)+{
++++System.out.println("String+is+immutable");
++++String+s+=+"test";
++++System.out.println(s%2B"::"%2Bs.hashCode());
++++for+(int+i+=+0;+i+<+10;+i%2B%2B)+{
++++++++s+%2B=+"tre";
++++++++System.out.println(s%2B"::"%2Bs.hashCode());
++++}

++++System.out.println("String+Buffer+is+mutable");

++++StringBuffer+strBuf+=+new+StringBuffer("test");
++++System.out.println(strBuf%2B"::"%2BstrBuf.hashCode());
++++for+(int+i+=+0;+i+<+10;+i%2B%2B)+{
++++++++strBuf.append("tre");
++++++++System.out.println(strBuf%2B"::"%2BstrBuf.hashCode());
++++}

+}

}|code-block|syntax|javascript|1089107|输出:它打印对象的值及其哈希码|1089108|++++String+is+immutable
++++test::3556498
++++testtre::-1422435371
++++testtretre::-1624680014
++++testtretretre::-855723339
++++testtretretretre::2071992018
++++testtretretretretre::-555654763
++++testtretretretretretre::-706970638
++++testtretretretretretretre::1157458037
++++testtretretretretretretretre::1835043090
++++testtretretretretretretretretre::1425065813
++++testtretretretretretretretretretre::-1615970766
++++String+Buffer+is+mutable
++++test::28117098
++++testtre::28117098
++++testtretre::28117098
++++testtretretre::28117098
++++testtretretretre::28117098
++++testtretretretretre::28117098
++++testtretretretretretre::28117098
++++testtretretretretretretre::28117098
++++testtretretretretretretretre::28117098
++++testtretretretretretretretretre::28117098
++++testtretretretretretretretretretre::28117098|1089109|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|$]]

By printing the hashcode of the String/StringBuffer object after any append operation also prove, String object is getting recreated internally every time with new values rather than using the same String object.

<pre><code>public class MutableImmutable {

/**
 * @param args
 */
public static void main(String[] args) {
 System.out.println("String is immutable");
 String s = "test";
 System.out.println(s+"::"+s.hashCode());
 for (int i = 0; i &lt; 10; i++) {
 s += "tre";
 System.out.println(s+"::"+s.hashCode());
 }

 System.out.println("String Buffer is mutable");

 StringBuffer strBuf = new StringBuffer("test");
 System.out.println(strBuf+"::"+strBuf.hashCode());
 for (int i = 0; i &lt; 10; i++) {
 strBuf.append("tre");
 System.out.println(strBuf+"::"+strBuf.hashCode());
 }

 }

}
</code></pre>

Output:
It prints object value along with its hashcode

<pre><code> String is immutable
 test::3556498
 testtre::-1422435371
 testtretre::-1624680014
 testtretretre::-855723339
 testtretretretre::2071992018
 testtretretretretre::-555654763
 testtretretretretretre::-706970638
 testtretretretretretretre::1157458037
 testtretretretretretretretre::1835043090
 testtretretretretretretretretre::1425065813
 testtretretretretretretretretretre::-1615970766
 String Buffer is mutable
 test::28117098
 testtre::28117098
 testtretre::28117098
 testtretretre::28117098
 testtretretretre::28117098
 testtretretretretre::28117098
 testtretretretretretre::28117098
 testtretretretretretretre::28117098
 testtretretretretretretretre::28117098
 testtretretretretretretretretre::28117098
 testtretretretretretretretretretre::28117098
</code></pre>

What is the difference between String and StringBuffer in Java?

Is there a maximum size for String?

What is the difference between String and StringBuffer in Java?

编译器

Java

在Java语言中，String和StringBuffer有什么不同？字符串有最大长度限制吗？

问在Java语言中，String和StringBuffer有什么不同？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java语言中，String和StringBuffer有什么不同？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java语言中，String和StringBuffer有什么不同？
EN