stringbuffer _生活經(jīng)驗(yàn)

JAVA 中的StringBuffer是什么東西，是拿來干什么的。你可以看它與String的區(qū)別主要用于拼接字符串是一個(gè)可變長的字符竄1、StringBuffer對象的初始化StringBuffer對象的初始化不像String類的初始化一樣，Java提供的有特殊的語法，而通常情況下一般使用構(gòu)造方法進(jìn)行初始化。例如：StringBuffer s = new StringBuffer();這樣初始化出的StringBuffer對象是一個(gè)空的對象。如果需要?jiǎng)?chuàng)建帶有內(nèi)容的StringBuffer對象，則可以使用：StringBuffer s = new StringBuffer(“abc”);這樣初始化出的StringBuffer對象的內(nèi)容就是字符串”abc” 。需要注意的是，StringBuffer和String屬于不同的類型，也不能直接進(jìn)行強(qiáng)制類型轉(zhuǎn)換，下面的代碼都是錯(cuò)誤的：StringBuffer s = “abc”;//賦值類型不匹配StringBuffer s = (StringBuffer)”abc”;//不存在繼承關(guān)系，無法進(jìn)行強(qiáng)轉(zhuǎn)StringBuffer對象和String對象之間的互轉(zhuǎn)的代碼如下：String s = “abc”;StringBuffer sb1 = new StringBuffer(“123”);StringBuffer sb2 = new StringBuffer(s);//String轉(zhuǎn)換為StringBufferString s1 = sb1.toString();//StringBuffer轉(zhuǎn)換為String2、StringBuffer的常用方法StringBuffer類中的方法主要偏重于對于字符串的變化，例如追加、插入和刪除等，這個(gè)也是StringBuffer和String類的主要區(qū)別。a、append方法public StringBuffer append(boolean b)該方法的作用是追加內(nèi)容到當(dāng)前StringBuffer對象的末尾，類似于字符串的連接。調(diào)用該方法以后， StringBuffer對象的內(nèi)容也發(fā)生改變，例如：StringBuffer sb = new StringBuffer(“abc”);sb.append(true);則對象sb的值將變成”abctrue” 。使用該方法進(jìn)行字符串的連接，將比String更加節(jié)約內(nèi)容，例如應(yīng)用于數(shù)據(jù)庫SQL語句的連接，例如：StringBuffer sb = new StringBuffer();String user = “test”;String pwd = “123”;sb.append(“select * from userInfo where username=“).append(user).append(“ and pwd=”).append(pwd);這樣對象sb的值就是字符串“select * from userInfo where username=test and pwd=123” 。b、deleteCharAt方法public StringBuffer deleteCharAt(int index)該方法的作用是刪除指定位置的字符，然后將剩余的內(nèi)容形成新的字符串。例如：StringBuffer sb = new StringBuffer(“Test”);sb. deleteCharAt(1);該代碼的作用刪除字符串對象sb中索引值為1的字符，也就是刪除第二個(gè)字符，剩余的內(nèi)容組成一個(gè)新的字符串。所以對象sb的值變?yōu)椤盩st” 。還存在一個(gè)功能類似的delete方法：public StringBuffer delete(int start,int end)該方法的作用是刪除指定區(qū)間以內(nèi)的所有字符，包含start，不包含end索引值的區(qū)間。例如：StringBuffer sb = new StringBuffer(“TestString”);sb. delete (1,4);該代碼的作用是刪除索引值1(包括)到索引值4(不包括)之間的所有字符，剩余的字符形成新的字符串。則對象sb的值是”TString” 。c、insert方法public StringBuffer insert(int offset, boolean b)該方法的作用是在StringBuffer對象中插入內(nèi)容，然后形成新的字符串。例如：StringBuffer sb = new StringBuffer(“TestString”);sb.insert(4,false);該示例代碼的作用是在對象sb的索引值4的位置插入false值，形成新的字符串，則執(zhí)行以后對象sb的值是”TestfalseString” 。d、reverse方法public StringBuffer reverse()該方法的作用是將StringBuffer對象中的內(nèi)容反轉(zhuǎn)，然后形成新的字符串。例如：StringBuffer sb = new StringBuffer(“abc”);sb.reverse();經(jīng)過反轉(zhuǎn)以后，對象sb中的內(nèi)容將變?yōu)椤眂ba” 。e、setCharAt方法public void setCharAt(int index, char ch)該方法的作用是修改對象中索引值為index位置的字符為新的字符ch 。例如：StringBuffer sb = new StringBuffer(“abc”);sb.setCharAt(1,’D’);則對象sb的值將變成”aDc” 。f、trimToSize方法public void trimToSize()該方法的作用是將StringBuffer對象的中存儲空間縮小到和字符串長度一樣的長度，減少空間的浪費(fèi) 。

java中String 和StringBuffer有什么區(qū)別String和StringBuffer的區(qū)別，網(wǎng)上資料可以說是數(shù)不勝數(shù)，但是看到這篇文章，感覺里面做的小例子很有代表性，所以轉(zhuǎn)一下，并自己做了一點(diǎn)總結(jié) 。

在java中有3個(gè)類來負(fù)責(zé)字符的操作。
1.Character 是進(jìn)行單個(gè)字符操作的
2.String 對一串字符進(jìn)行操作。不可變類。
3.StringBuffer 也是對一串字符進(jìn)行操作，但是可變類。

String:
是對象不是原始類型.
為不可變對象,一旦被創(chuàng)建,就不能修改它的值.
對于已經(jīng)存在的String對象的修改都是重新創(chuàng)建一個(gè)新的對象,然后把新的值保存進(jìn)去.
String 是final類,即不能被繼承.

StringBuffer:
是一個(gè)可變對象,當(dāng)對他進(jìn)行修改的時(shí)候不會像String那樣重新建立對象
它只能通過構(gòu)造函數(shù)來建立,
StringBuffer sb = new StringBuffer();
note:不能通過付值符號對他進(jìn)行付值.
sb = "welcome to here!";//error
對象被建立以后,在內(nèi)存中就會分配內(nèi)存空間,并初始保存一個(gè)null.向StringBuffer
中付值的時(shí)候可以通過它的append方法.
sb.append("hello");

字符串連接操作中StringBuffer的效率要比String高:

String str = new String("welcome to ");
str += "here";
的處理步驟實(shí)際上是通過建立一個(gè)StringBuffer,然后調(diào)用append(),最后
再將StringBuffer toSting();
這樣的話String的連接操作就比StringBuffer多出了一些附加操作,當(dāng)然效率上要打折扣.

并且由于String 對象是不可變對象,每次操作Sting 都會重新建立新的對象來保存新的值.
這樣原來的對象就沒用了,就要被垃圾回收.這也是要影響性能的.

看看以下代碼：
將26個(gè)英文字母重復(fù)加了5000次，

Java代碼
1.String tempstr = "abcdefghijklmnopqrstuvwxyz";
2.int times = 5000;
3.long lstart1 = System.currentTimeMillis();
4.String str = "";
5.for (int i = 0; i < times; i++) {
6.str += tempstr;
7.}
8.long lend1 = System.currentTimeMillis();
9.long time = (lend1 - lstart1);
10.System.out.println(time);
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lstart1 = System.currentTimeMillis();
String str = "";
for (int i = 0; i < times; i++) {
str += tempstr;
}
long lend1 = System.currentTimeMillis();
long time = (lend1 - lstart1);
System.out.println(time);

可惜我的計(jì)算機(jī)不是超級計(jì)算機(jī)，得到的結(jié)果每次不一定一樣一般為 46687左右。
也就是46秒。
我們再看看以下代碼

Java代碼
1.String tempstr = "abcdefghijklmnopqrstuvwxyz";
2.int times = 5000;
3.long lstart2 = System.currentTimeMillis();
4.StringBuffer sb = new StringBuffer();
5.for (int i = 0; i < times; i++) {
6.sb.append(tempstr);
7.}
8.long lend2 = System.currentTimeMillis();
9.long time2 = (lend2 - lstart2);
10.System.out.println(time2);
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lstart2 = System.currentTimeMillis();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < times; i++) {
sb.append(tempstr);
}
long lend2 = System.currentTimeMillis();
long time2 = (lend2 - lstart2);
System.out.println(time2);

得到的結(jié)果為 16 有時(shí)還是 0
所以結(jié)論很明顯，StringBuffer 的速度幾乎是String 上萬倍。當(dāng)然這個(gè)數(shù)據(jù)不是很準(zhǔn)確。因?yàn)檠h(huán)的次數(shù)在100000次的時(shí)候，差異更大。不信你試試。

根據(jù)上面所說：

str += "here";
的處理步驟實(shí)際上是通過建立一個(gè)StringBuffer,讓侯調(diào)用append(),最后
再將StringBuffer toSting();

所以str += "here";可以等同于

StringBuffer sb = new StringBuffer(str);

sb.append("here");

str = sb.toString();

所以上面直接利用"+"來連接String的代碼可以基本等同于以下代碼

Java代碼
1.String tempstr = "abcdefghijklmnopqrstuvwxyz";
2.int times = 5000;
3.long lstart2 = System.currentTimeMillis();
4.String str = "";
5.for (int i = 0; i < times; i++) {
6.StringBuffer sb = new StringBuffer(str);
7.sb.append(tempstr);
8.str = sb.toString();
9.}
10.long lend2 = System.currentTimeMillis();
11.long time2 = (lend2 - lstart2);
12.System.out.println(time2);
String tempstr = "abcdefghijklmnopqrstuvwxyz";
int times = 5000;
long lstart2 = System.currentTimeMillis();
String str = "";
for (int i = 0; i < times; i++) {
StringBuffer sb = new StringBuffer(str);
sb.append(tempstr);
str = sb.toString();
}
long lend2 = System.currentTimeMillis();
long time2 = (lend2 - lstart2);
System.out.println(time2);

平均執(zhí)行時(shí)間為46922左右，也就是46秒。

總結(jié): 如果在程序中需要對字符串進(jìn)行頻繁的修改連接操作的話.使用StringBuffer性能會更高

本文來自CSDN博客，轉(zhuǎn)載請標(biāo)明出處：http://blog.csdn.net/yirentianran/archive/2008/09/03/2871417.aspx

--------------------------------------------------------------------------------------------------------------------------------------------
另外一段網(wǎng)上對String與StringBuffer區(qū)別的注解:

String和StringBuffer
String 是不可以變的字符串.
StringBuffer 是可變的字符串.
對StringBuffer進(jìn)行操作,是在原來的對象之上進(jìn)行改變. 而對String進(jìn)行操作,是創(chuàng)建新的對象。

Java代碼
1.public class StringTest {
2.public static void stringReplace(String text) {
3.text = text.replace('j', 'i');
4.}
5.
6.public static void bufferReplace(StringBuffer text) {
7.text = text.append("C");
8.}
9.
10.public static void main(String args[]) {
11.String textString = new String("java");
12.StringBuffer textBuffer = new StringBuffer("java");
13.
14.stringReplace(textString);
15.bufferReplace(textBuffer);
16.
17.System.out.println(textString + textBuffer);
18.}
19.}
public class StringTest {
public static void stringReplace(String text) {
text = text.replace('j', 'i');
}

public static void bufferReplace(StringBuffer text) {
text = text.append("C");
}

public static void main(String args[]) {
String textString = new String("java");
StringBuffer textBuffer = new StringBuffer("java");

stringReplace(textString);
bufferReplace(textBuffer);

System.out.println(textString + textBuffer);
}
}

輸出結(jié)果
javajavaC
String實(shí)例化以后所有的屬性都是final的，而StringBuffer確不是，這就是可變與不可變。
這是因?yàn)榈谄咝衪ext = text.append ("C")，append方法會改變text中的值,而text與textBuffer指向的地址是相同的。因此會打印javaC
再舉個(gè)例子：
String a = "a"; //假設(shè)a指向地址0x0001
a = "b"; //重新賦值后a指向地址0x0002，但0x0001地址中保存的"a"依舊存在，但已經(jīng)不再是a所指向的。
因此String的操作都是改變賦值地址而不是改變值操作。
具體：
String:在String類中沒有用來改變已有字符串中的某個(gè)字符的方法，由于不能改變一個(gè)java字符串中的某個(gè)單獨(dú)字符，所以在JDK文檔中稱String類的對象是不可改變的。然而，不可改變的字符串具有一個(gè)很大的優(yōu)點(diǎn):編譯器可以把字符串設(shè)為共享的。
StringBuffer:StringBuffer類屬于一種輔助類，可預(yù)先分配指定長度的內(nèi)存塊建立一個(gè)字符串緩沖區(qū) 。這樣使用
StringBuffer類的append方法追加字符比String使用 + 操作符添加字符到一個(gè)已經(jīng)存在的字符串后面有效率得多。因?yàn)槭褂?+ 操作符每一次將字符添加到一個(gè)字符串中去時(shí)，字符串對象都需要尋找一個(gè)新的內(nèi)存空間來容納更大的字符串，這無凝是一個(gè)非常消耗時(shí)間的操作。添加多個(gè)字符也就意味著要一次又一次的對字符串重新分配內(nèi)存。使用StringBuffer類就避免了這個(gè)問題.

java中StringBuffer是什么，怎么用？public final class StringBufferextends Objectimplements Serializable, CharSequence
線程安全的可變字符序列。一個(gè)類似于 String 的字符串緩沖區(qū)，但不能修改。雖然在任意時(shí)間點(diǎn)上它都包含某種特定的字符序列，但通過某些方法調(diào)用可以改變該序列的長度和內(nèi)容。
可將字符串緩沖區(qū)安全地用于多個(gè)線程。可以在必要時(shí)對這些方法進(jìn)行同步，因此任意特定實(shí)例上的所有操作就好像是以串行順序發(fā)生的，該順序與所涉及的每個(gè)線程進(jìn)行的方法調(diào)用順序一致。

StringBuffer 上的主要操作是 append 和 insert 方法，可重載這些方法，以接受任意類型的數(shù)據(jù) 。每個(gè)方法都能有效地將給定的數(shù)據(jù)轉(zhuǎn)換成字符串，然后將該字符串的字符追加或插入到字符串緩沖區(qū)中。append 方法始終將這些字符添加到緩沖區(qū)的末端；而 insert 方法則在指定的點(diǎn)添加字符。
例如，如果 z 引用一個(gè)當(dāng)前內(nèi)容為 "start" 的字符串緩沖區(qū)對象，則此方法調(diào)用z.append("le") 會使字符串緩沖區(qū)包含 "startle"，而 z.insert(4, "le") 將更改字符串緩沖區(qū)，使之包含 "starlet" 。
通常，如果 sb 引用 StringBuilder 的一個(gè)實(shí)例，則 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。
當(dāng)發(fā)生與源序列有關(guān)的操作（如源序列中的追加或插入操作）時(shí) ，該類只在執(zhí)行此操作的字符串緩沖區(qū)上而不是在源上實(shí)現(xiàn)同步。
每個(gè)字符串緩沖區(qū)都有一定的容量。只要字符串緩沖區(qū)所包含的字符序列的長度沒有超出此容量，就無需分配新的內(nèi)部緩沖區(qū)數(shù)組。如果內(nèi)部緩沖區(qū)溢出，則此容量自動增大。從 JDK 5 開始，為該類補(bǔ)充了一個(gè)單個(gè)線程使用的等價(jià)類，即 StringBuilder 。與該類相比，通常應(yīng)該優(yōu)先使用 StringBuilder 類，因?yàn)樗С炙邢嗤牟僮鳎捎谒粓?zhí)行同步，所以速度更快。

基本方法append(),insert(),substring(),delete(),replace(),indexOf()這種,具體就查手冊吧，一大堆方法呢

請問java Stringbuffer在什么情況下用到？一般在字符串拼接時(shí)使用具體代碼如下：public class BaiduTest { public static void main(String[] args) {// TODO Auto-generated method stubString a="aaaa";String b="bbbbbb";StringBuffer ab=new StringBuffer();ab.append(a).append("-").append(b);System.out.println(ab.toString());}}執(zhí)行結(jié)果：
JAVA中StringBuffer與StringBuilder、String的區(qū)別是什么？java中String、StringBuffer、StringBuilder是編程中經(jīng)常使用的字符串操作類。
1.可變與不可變
String類中使用字符數(shù)組保存字符串，如下就是，因?yàn)橛小癴inal”修飾符，所以可以知道string對象是不可變的。
private final char value[];
StringBuilder與StringBuffer都繼承自AbstractStringBuilder類，在AbstractStringBuilder中也是使用字符數(shù)組保存字符串，如下就是，可知這兩種對象都是可變的。
char[] value;

2.是否多線程安全
String中的對象是不可變的，也就可以理解為常量，顯然線程安全。
AbstractStringBuilder是StringBuilder與StringBuffer的公共父類，定義了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。
StringBuffer對方法加了同步鎖或者對調(diào)用的方法加了同步鎖，所以是線程安全的。看如下源碼：
public synchronized StringBuffer reverse() {
super.reverse();
return this;
}

public int indexOf(String str) {
return indexOf(str, 0);//存在 public synchronized int indexOf(String str, int fromIndex) 方法
}
StringBuilder并沒有對方法進(jìn)行加同步鎖，所以是非線程安全的。

3.StringBuilder與StringBuffer共同點(diǎn)
StringBuilder與StringBuffer有公共父類AbstractStringBuilder(抽象類) 。
抽象類與接口的其中一個(gè)區(qū)別是：抽象類中可以定義一些子類的公共方法，子類只需要增加新的功能，不需要重復(fù)寫已經(jīng)存在的方法；而接口中只是對方法的申明和常量的定義。
StringBuilder、StringBuffer的方法都會調(diào)用AbstractStringBuilder中的公共方法，如super.append(...) 。只是StringBuffer會在方法上加synchronized關(guān)鍵字，進(jìn)行同步。
最后，如果程序不是多線程的，那么使用StringBuilder效率高于StringBuffer 。

stringbuffer與stringbuilder的區(qū)別?java中String、StringBuffer、StringBuilder是編程中經(jīng)常使用的字符串類，他們之間的區(qū)別也是經(jīng)常在面試中會問到的問題。現(xiàn)在總結(jié)一下，看看他們的不同與相同。
1.可變與不可變
String類中使用字符數(shù)組保存字符串，如下就是，因?yàn)橛小癴inal”修飾符，所以可以知道string對象是不可變的。
private final char value[];
StringBuilder與StringBuffer都繼承自AbstractStringBuilder類，在AbstractStringBuilder中也是使用字符數(shù)組保存字符串，如下就是，可知這兩種對象都是可變的。
char[] value;
2.是否多線程安全
String中的對象是不可變的，也就可以理解為常量，顯然線程安全。
AbstractStringBuilder是StringBuilder與StringBuffer的公共父類，定義了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。
StringBuffer對方法加了同步鎖或者對調(diào)用的方法加了同步鎖，所以是線程安全的。看如下源碼：

public synchronized StringBuffer reverse() {
super.reverse();
return this;
}

public int indexOf(String str) {
return indexOf(str, 0);//存在 public synchronized int indexOf(String str, int fromIndex) 方法
}

StringBuilder并沒有對方法進(jìn)行加同步鎖，所以是非線程安全的。
3.StringBuilder與StringBuffer共同點(diǎn)
StringBuilder與StringBuffer有公共父類AbstractStringBuilder(抽象類) 。
抽象類與接口的其中一個(gè)區(qū)別是：抽象類中可以定義一些子類的公共方法，子類只需要增加新的功能，不需要重復(fù)寫已經(jīng)存在的方法；而接口中只是對方法的申明和常量的定義。
StringBuilder、StringBuffer的方法都會調(diào)用AbstractStringBuilder中的公共方法，如super.append(...) 。只是StringBuffer會在方法上加synchronized關(guān)鍵字，進(jìn)行同步。
最后，如果程序不是多線程的，那么使用StringBuilder效率高于StringBuffer 。

Java中String和StringBuffer的區(qū)別?String 不是簡單類型，而是一個(gè)類，它被用來表示字符序列。字符本身符合 Unicode 標(biāo)準(zhǔn)，其初始化方式有兩種。
如：String greeting=“Good Morning! \n”;
String greeting=new String(=“Good Morning! \n”);
String的特點(diǎn)是一旦賦值，便不能更改其指向的字符對象，如果更改，則會指向一個(gè)新的字符對象。

StringBuffer是一個(gè)具有對象引用傳遞特點(diǎn)的字符串對象。
StringBuffer對象可以調(diào)用其方法動態(tài)的進(jìn)行增加、插入、修改和刪除操作，且不用像數(shù)組那樣事先指定大小，從而實(shí)現(xiàn)多次插入字符，一次整體取出的效果，因而操作字符串非常靈活方便。
一旦通過StringBuffer生成最終想要的字符串，就可調(diào)用它的toString方法將其轉(zhuǎn)換為一個(gè)String對象

String和StringBuffer有什么區(qū)別?。?/h3>StringBuffer是一個(gè)具有對象引用傳遞特點(diǎn)的字符串對象。StringBuffer對象可以調(diào)用其方法動態(tài)的進(jìn)行增加、插入、修改和刪除操作，且不用像數(shù)組那樣事先指定大小，從而實(shí)現(xiàn)多次插入字符，一次整體取出的效果，因而操作字符串非常靈活方便。一旦通過StringBuffer生成最終想要的字符串，就可調(diào)用它的toString方法將其轉(zhuǎn)換為一個(gè)String對象追問： StringBuffer調(diào)用它的toString方法指向一個(gè)地址，最后還是變成了一個(gè)String對象，為什么在不直接用String呢？如：pstmt = con.prepareStatement(sql.toString());和String sql1 = "select * from ...";pstmt = con.prepareStatement(sql1); 回答： String的操作都是改變賦值地址而不是改變值操作 String 類和 StringBuffer 類的比較：相同： 1: 都是用來處理字符串的 2：都提供了 length() , toString() ,charAt() , substring() 方法，用法一樣 3：對于String 類和 StringBuffer 類，字符在字符串中的索引位置都從 0 開始。4：兩個(gè)類的 substring( int beginIndex, int endIndex)方法都是用來截取字符串，且范圍都是從beginIndex 開始，到 endIndex--1 為止。不同： 1: String 類是不可變類， StringBuffer 類是可變類 String 類提供的比如 substring，replace 等方法都不會更改字符串內(nèi)容，實(shí)際上是創(chuàng)建一個(gè)方法所浮于特性的新字符串。返回一個(gè)改變后內(nèi)容的新字符串。StringBuffer 的 appeng(),等方法都會改變字符緩沖區(qū)中的字符串內(nèi)容。2：String 類覆蓋了Object類的 equals（）方法 StringBuffer類沒有覆蓋 3：都覆蓋了Object()類的 toString() 方法，實(shí)現(xiàn)不一樣 String類的toString() 方法返回當(dāng)前String實(shí)例本身的引用。StringBuffer類的toString方法返回一個(gè)以當(dāng)前StringBuffer的緩沖區(qū)中的所有字符串為內(nèi)容的新的 String對象的引用。4： String 對象可以用操作符 "+ " 進(jìn)行連接 StringBuffer 不能追問：我懂了String sql =“hello word”；相當(dāng)于String創(chuàng)建以后就有了空的字符，然后將字符串“hello word”賦值給它，得到新的字符串。StringBuffer類的toString方法類似于把創(chuàng)建后的空字符串改變成新的字符串，沒有重新賦值。可以這樣理解嗎？回答：簡單點(diǎn)說用StringBuffer主要是為了對字符進(jìn)行增加、插入、修改和刪除操作，而String 是操作完成后用來存儲字符的。就好像說一塊固態(tài)（String）的金磚，你想改變的的形狀就的先融化成液態(tài)（StringBuffer），等形狀確定以后再變成固態(tài)（String）。這個(gè)比方并不是很恰當(dāng)，不過應(yīng)該更好一點(diǎn)理解。補(bǔ)充：你的理解只能說沒錯(cuò)，卻也不完全正確。追問：感謝！回答：不客氣，互相交流一下，我現(xiàn)在都很少用Java了，改行學(xué)C++

請問java中的String類和StringBuffer類有什么區(qū)別與聯(lián)系，謝！在java中有3個(gè)類來負(fù)責(zé)字符的操作。
1.Character 是進(jìn)行單個(gè)字符操作的，
2.String 對一串字符進(jìn)行操作。不可變類。
3.StringBuffer 也是對一串字符進(jìn)行操作，但是可變類。
String:
是對象不是原始類型.
為不可變對象,一旦被創(chuàng)建,就不能修改它的值.
對于已經(jīng)存在的String對象的修改都是重新創(chuàng)建一個(gè)新的對象,然后把新的值保存進(jìn)去.
String 是final類,即不能被繼承.

StringBuffer:
是一個(gè)可變對象,當(dāng)對他進(jìn)行修改的時(shí)候不會像String那樣重新建立對象
它只能通過構(gòu)造函數(shù)來建立,
StringBuffer sb = new StringBuffer();
note:不能通過付值符號對他進(jìn)行付值.
sb = "welcome to here!";//error
對象被建立以后,在內(nèi)存中就會分配內(nèi)存空間,并初始保存一個(gè)null.向StringBuffer
中付值的時(shí)候可以通過它的append方法.
sb.append("hello");

字符串連接操作中StringBuffer的效率要比String高:
String str = new String("welcome to ");
str += "here";
的處理步驟實(shí)際上是通過建立一個(gè)StringBuffer,讓侯調(diào)用append(),最后
再將StringBuffer toSting();
這樣的話String的連接操作就比StringBuffer多出了一些附加操作,當(dāng)然效率上要打折扣.

并且由于String 對象是不可變對象,每次操作Sting 都會重新建立新的對象來保存新的值.這樣原來的對象就沒用了,就要被垃圾回收.這也是要影響性能的.

JAVA的String類和StringBuffer兩個(gè)類的區(qū)別StringBuffer類和String一樣，也用來代表字符串，只是由于StringBuffer的內(nèi)部實(shí)現(xiàn)方式和String不同，所以StringBuffer在進(jìn)行字符串處理時(shí)，不生成新的對象，在內(nèi)存使用上要優(yōu)于String類。所以在實(shí)際使用時(shí)，如果經(jīng)常需要對一個(gè)字符串進(jìn)行修改，例如插入、刪除等操作，使用StringBuffer要更加適合一些。在StringBuffer類中存在很多和String類一樣的方法，這些方法在功能上和String類中的功能是完全一樣的。但是有一個(gè)最顯著的區(qū)別在于，對于StringBuffer對象的每次修改都會改變對象自身，這點(diǎn)是和String類最大的區(qū)別。另外由于StringBuffer是線程安全的，所以在多線程程序中也可以很方便的進(jìn)行使用，但是程序的執(zhí)行效率相對來說就要稍微慢一些。1、StringBuffer對象的初始化StringBuffer對象的初始化不像String類的初始化一樣，Java提供的有特殊的語法，而通常情況下一般使用構(gòu)造方法進(jìn)行初始化。例如：StringBuffer s = new StringBuffer();這樣初始化出的StringBuffer對象是一個(gè)空的對象。如果需要?jiǎng)?chuàng)建帶有內(nèi)容的StringBuffer對象，則可以使用：StringBuffer s = new StringBuffer(“abc”);這樣初始化出的StringBuffer對象的內(nèi)容就是字符串”abc” 。需要注意的是，StringBuffer和String屬于不同的類型，也不能直接進(jìn)行強(qiáng)制類型轉(zhuǎn)換，下面的代碼都是錯(cuò)誤的：StringBuffer s = “abc”;//賦值類型不匹配StringBuffer s = (StringBuffer)”abc”;//不存在繼承關(guān)系，無法進(jìn)行強(qiáng)轉(zhuǎn)StringBuffer對象和String對象之間的互轉(zhuǎn)的代碼如下：String s = “abc”;StringBuffer sb1 = new StringBuffer(“123”);StringBuffer sb2 = new StringBuffer(s);//String轉(zhuǎn)換為StringBufferString s1 = sb1.toString();//StringBuffer轉(zhuǎn)換為String2、StringBuffer的常用方法StringBuffer類中的方法主要偏重于對于字符串的變化，例如追加、插入和刪除等，這個(gè)也是StringBuffer和String類的主要區(qū)別。a、append方法public StringBuffer append(boolean b)該方法的作用是追加內(nèi)容到當(dāng)前StringBuffer對象的末尾，類似于字符串的連接。調(diào)用該方法以后，StringBuffer對象的內(nèi)容也發(fā)生改變，例如：StringBuffe sb = new StringBuffer(“abc”);sb.append(true);則對象sb的值將變成”abctrue” 。使用該方法進(jìn)行字符串的連接，將比String更加節(jié)約內(nèi)容，例如應(yīng)用于數(shù)據(jù)庫SQL語句的連接，例如：StringBuffer sb = new StringBuffer();String user = “test”;String pwd = “123”;sb.append(“select * from userInfo where username=“).append(user).append(“ and pwd=”).append(pwd);這樣對象sb的值就是字符串“select * from userInfo where username=test and pwd=123” 。b、deleteCharAt方法public StringBuffer deleteCharAt(int index)該方法的作用是刪除指定位置的字符，然后將剩余的內(nèi)容形成新的字符串。例如：StringBuffer sb = new StringBuffer(“Test”);sb.deleteCharAt(1);該代碼的作用刪除字符串對象sb中索引值為1的字符，也就是刪除第二個(gè)字符，剩余的內(nèi)容組成一個(gè)新的字符串。所以對象sb的值變?yōu)椤盩st” 。還存在一個(gè)功能類似的delete方法：public StringBuffer delete(int start,int end)該方法的作用是刪除指定區(qū)間以內(nèi)的所有字符，包含start ，不包含end索引值的區(qū)間。例如：StringBuffer sb = new StringBuffer(“TestString”);sb.delete (1,4);該代碼的作用是刪除索引值1(包括)到索引值4(不包括)之間的所有字符，剩余的字符形成新的字符串。則對象sb的值是”TString” 。c、insert方法public StringBuffer insert(int offset, boolean b)該方法的作用是在StringBuffer對象中插入內(nèi)容，然后形成新的字符串。例如：StringBuffer sb = new StringBuffer(“TestString”);sb.insert(4,false);該示例代碼的作用是在對象sb的索引值4的位置插入false值，形成新的字符串，則執(zhí)行以后對象sb的值是”TestfalseString” 。d、reverse方法public StringBuffer reverse()該方法的作用是將StringBuffer對象中的內(nèi)容反轉(zhuǎn)，然后形成新的字符串。例如：StringBuffer sb = new StringBuffer(“abc”);sb.reverse();經(jīng)過反轉(zhuǎn)以后，對象sb中的內(nèi)容將變?yōu)椤眂ba” 。e、setCharAt方法public void setCharAt(int index, char ch)該方法的作用是修改對象中索引值為index位置的字符為新的字符ch 。例如：StringBuffer sb = new StringBuffer(“abc”);sb.setCharAt(1,’D’);則對象sb的值將變成”aDc” 。f、trimToSize方法public void trimToSize()該方法的作用是將StringBuffer對象的中存儲空間縮小到和字符串長度一樣的長度，減少空間的浪費(fèi) 。總之，在實(shí)際使用時(shí)，String和StringBuffer各有優(yōu)勢和不足，可以根據(jù)具體的使用環(huán)境，選擇對應(yīng)的類型進(jìn)行使用。
Java中String和StringBuffer的區(qū)別1.就是一個(gè)變量和常量的關(guān)系。StringBuffer對象的內(nèi)容可以修改；而String對象一旦產(chǎn)生后就不可以被修改，重新賦值其實(shí)是兩個(gè)對象。2.StringBuffer的內(nèi)部實(shí)現(xiàn)方式和String不同，StringBuffer在進(jìn)行字符串處理時(shí)，不生成新的對象，在內(nèi)存使用上要優(yōu)于String類。所以在實(shí)際使用時(shí)，如果經(jīng)常需要對一個(gè)字符串進(jìn)行修改，3.插入、刪除等操作，使用StringBuffer要更加適合一些。String對象創(chuàng)建以后就不能修改了，除非讓String類型的引用指向另一個(gè)String對象。
Java中String和StringBuffer的區(qū)別是什么？1.就是一個(gè)變量和常量的關(guān)系。StringBuffer對象的內(nèi)容可以修改；而String對象一旦產(chǎn)生后就不可以被修改，重新賦值其實(shí)是兩個(gè)對象。2.StringBuffer的內(nèi)部實(shí)現(xiàn)方式和String不同，StringBuffer在進(jìn)行字符串處理時(shí)，不生成新的對象，在內(nèi)存使用上要優(yōu)于String類。所以在實(shí)際使用時(shí)，如果經(jīng)常需要對一個(gè)字符串進(jìn)行修改， 3.插入、刪除等操作，使用StringBuffer要更加適合一些。String對象創(chuàng)建以后就不能修改了，除非讓String類型的引用指向另一個(gè)String對象。
java中String和StringBuffered有什么區(qū)別?樓上別在擺渡里隨便搞一段來糊弄人拉其實(shí)String和StringBuffer很簡單：在String中有“池”這么一個(gè)概念，不知道樓主知道不知道，比如說String str="hello" 這句話創(chuàng)建了兩個(gè)對象，一個(gè)是str這個(gè)對象，另外一個(gè)就是在池中創(chuàng)建的"hello"，接著str="helloMan"，使用這句話的時(shí)候，虛擬機(jī)首先會去池中找有沒有"helloMan"字符串，如果有的話，就拿池中的來用，沒有的話就和之前那句代碼一樣處理，這樣一來，無論從效率上還是內(nèi)存消耗上來講都是比較大的，因?yàn)镾tring類是final類型的（這個(gè)可以參考API或者源代碼）。而StringBuffer就不一樣了，是JAVA專門用來處理字符串拼接問題的一個(gè)類，StringBuffer sb="a"; sb="ab"; 第二句代碼就不會創(chuàng)建新的實(shí)例了，而是在a的后面加了一個(gè)b 。以前我做過一個(gè)測試，就是測試一下String類和StringBuffer在處理字符串拼接的時(shí)候的效率問題，結(jié)果證明StringBuffer的處理速度是String類處理速度的1000倍，也就是說StringBuffer處理一秒的事情String類要處理16分鐘還多。

說明string和stringbuffer的優(yōu)缺點(diǎn)，并舉例說明？1. String 類String的值是不可變的，這就導(dǎo)致每次對String的操作都會生成新的String對象，不僅效率低下，而且大量浪費(fèi)有限的內(nèi)存空間。String a = "a"; //假設(shè)a指向地址0x0001a = "b";//重新賦值后a指向地址0x0002，但0x0001地址中保存的"a"依舊存在，但已經(jīng)不再是a所指向的,a 已經(jīng)指向了其它地址。因此String的操作都是改變賦值地址而不是改變值操作。2. StringBuffer是可變類，和線程安全的字符串操作類，任何對它指向的字符串的操作都不會產(chǎn)生新的對象。每個(gè)StringBuffer對象都有一定的緩沖區(qū)容量，當(dāng)字符串大小沒有超過容量時(shí)，不會分配新的容量，當(dāng)字符串大小超過容量時(shí)，會自動增加容量。StringBuffer buf=new StringBuffer(); //分配長16字節(jié)的字符緩沖區(qū)StringBuffer buf=new StringBuffer(512); //分配長512字節(jié)的字符緩沖區(qū)StringBuffer buf=new StringBuffer("this is a test")//在緩沖區(qū)中存放了字符串，并在后面預(yù)留了16字節(jié)的空緩沖區(qū) 。3.StringBufferStringBuffer和StringBuilder類功能基本相似，主要區(qū)別在于StringBuffer類的方法是多線程、安全的，而StringBuilder不是線程安全的，相比而言， StringBuilder類會略微快一點(diǎn) 。對于經(jīng)常要改變值的字符串應(yīng)該使用StringBuffer和StringBuilder類。4.線程安全StringBuffer 線程安全StringBuilder 線程不安全5.速度一般情況下,速度從快到慢:StringBuilder>StringBuffer>String,這種比較是相對的，不是絕對的。6.總結(jié)（1）.如果要操作少量的數(shù)據(jù)用 = String（2）.單線程操作字符串緩沖區(qū) 下操作大量數(shù)據(jù) = StringBuilder（3）.多線程操作字符串緩沖區(qū) 下操作大量數(shù)據(jù) = StringBuffer

StringBuffer是什么?StringBuffer類常用方法簡介StringBuffer類用于處理可變的字符串，它提供修改字符串的方法。（1）構(gòu)造方法：a. StringBuffer s0=new StringBuffer();分配了長16字節(jié)的字符緩沖區(qū)b. StringBuffer s1=new StringBuffer(512);分配了512字節(jié)的字符緩沖區(qū)c. StringBuffer s2=new StringBuffer("You are good!"); 在字符緩沖區(qū)中存放字符串"Happy new year！" ，另外，后面再留了16字節(jié)的空緩沖區(qū) 。（2）常用方法：a．字符設(shè)置和替換setCharAt(int index,char ch),將指定的字符ch放到index指出的位置。charAt(int index) 獲得指定位置的字符例如：s="stedent";s.setCharAt(2,"u"),則s為"student"b.字符的插入insert(int offset,char ch),在offset位置插入字符ch 。例如：StringBuffer s=new StringBuffer("wecome");s.insert(2,'l'),則s為"welcome"c．在字符串末尾添加內(nèi)容（Append方法）StringBuffer s=newStringBuffer("we");char d={"l","c","o","m","e"};s.append(d);則s為"welcome" 。d.轉(zhuǎn)換為不變字符串:toString() 。e.獲取字符串的長度: length()StringBuffer s = new StringBuffer("www");int i=s.length();f.獲取字符串的容量 s.capacity();g.重新設(shè)置字符串容量的大?。篹nsureCapacity() s.ensureCapacity(100);h.設(shè)置字符串緩沖區(qū)的大小 s.setlength(10); 如果用小于當(dāng)前字符串長度的值調(diào)用setlength()方法，則新長度后面的字符將丟失。i.將字符串的子字符串復(fù)制給數(shù)組 getChars(int start,int end,char chars[],int charsStart) String s1 = "This is a test"; int start =0; int end = 10; char ch1[] = new char[end-start]; s1.getChars(start,end,ch1,0); System.out.println(ch1);j.字符串反轉(zhuǎn) s.reverse();k.刪除指定字符串著中的字符 delete(int start,int end) s.delete(0,s.length()); //刪除字符串s的全部字符 deleteCharAt(int index) s.deleteCharAt(4); //刪除字符串s索引為4的字符l.替換字符串 replace(int start,int end,String str) s.replace(0,1,"qqq");m.返回字符串的一部分值 substring(int start) //返回從start下標(biāo)開始以后的字符串 substring(int start,int end) //返回從start到 end-1字符串

StringBuffer sb=new StringBuffer("內(nèi)容")構(gòu)造一個(gè)字符串sb ，內(nèi)容為“內(nèi)容”,相當(dāng)于String sb= new String("內(nèi)容");只是StringBuffer是帶有緩沖的字符串，如果頻繁修改效率上比String好

StringBuffer的使用方法public static void main(String[] args){
String[] strings = { "a", "b", "c", "d" };
StringBuffer stringBuffer = new StringBuffer();
for (String string : strings){
stringBuffer.append(string);
}
System.out.println(stringBuffer.toString());
}

Java中StringBuffer類append方法的使用參數(shù)將被轉(zhuǎn)換成字符串，就好象使用了 String.valueOf 方法一樣。然后，將所得字符串中的字符追加到此序列。參數(shù)：obj - 一個(gè) Object 。返回：此對象的一個(gè)引用。另請參見：String.valueOf(java.lang.Object), append(java.lang.String)appendpublic StringBuffer append(String str) 將指定的字符串追加到此字符序列。按順序追加 String 變量中的字符，使此序列增加該變量的長度。如果 str 為 null，則追加 4 個(gè)字符 "null" 。假設(shè)此字符序列的長度在執(zhí)行 append 方法前為 n 。如果 k 小于 n，則新字符序列中索引 k 處的字符等于原序列中索引 k 處的字符；否則它等于參數(shù) str 中索引 k-n 處的字符。參數(shù)：str - 一個(gè) string 。返回：此對象的一個(gè)引用。appendpublic StringBuffer append(StringBuffer sb) 將指定的 StringBuffer 追加到此序列中。按順序?qū)?StringBuffer 參數(shù)中的字符追加到此 StringBuffer 中，并使 StringBuffer 在長度上增加該參數(shù)的長度。如果 sb 為 null ，則將 4 個(gè) "null" 字符追加到此 StringBuffer 中。在執(zhí)行 append 方法前，讓 StringBuffer 中包含的原有字符序列的長度為 n 。如果 k 小于 n，則新字符序列中索引 k 處的字符等于原有字符序列中索引 k 處的字符；否則它等于參數(shù) sb 中索引 k-n 處的字符。該方法在 this（目標(biāo)）對象上實(shí)現(xiàn)同步，但不在源（sb）上實(shí)現(xiàn)同步。參數(shù)：sb - 要追加的 StringBuffer 。返回：該對象的一個(gè)引用。從以下版本開始：1.4 appendpublic StringBuffer append(CharSequence s) 將指定的 CharSequence 追加到該序列。按順序?qū)?CharSequence 參數(shù)中的字符追加到該序列中，使該序列增加該參數(shù)的長度。該方法的結(jié)果與調(diào)用 this.append(s, 0, s.length()) 的結(jié)果完全相同；該方法在 this（目標(biāo)）對象上實(shí)現(xiàn)同步，但不在源（s）上實(shí)現(xiàn)同步。如果s 為 null，則追加 4 個(gè) "null" 字符。指定者：接口Appendable 中的 append參數(shù)：s - 要追加的 CharSequence 。返回：此對象的一個(gè)引用。從以下版本開始：1.5 appendpublic StringBuffer append(CharSequence s, int start, int end) 將指定 CharSequence 的子序列追加到此序列。按順序追加參數(shù) s 中的字符，即從索引 start 開始到索引 end 結(jié)束的此序列的內(nèi)容。此序列增加的長度為 end - start 。假設(shè)此字符序列的長度在執(zhí)行 append 方法前為 n 。如果 k 小于 n，則新字符序列中索引 k 處的字符等于原序列中索引 k 處的字符；否則它等于參數(shù) s 中索引 k+start-n 處的字符。如果s 為 null ，則認(rèn)為 s 參數(shù)包含 4 個(gè)字符 "null"，并以此為根據(jù)追加字符。指定者：接口Appendable 中的 append參數(shù)：s - 要追加的序列。start - 要追加的子序列的起始索引。end - 要追加的子序列的結(jié)束索引。返回：此對象的一個(gè)引用。拋出：IndexOutOfBoundsException 如果 start 或 end 為負(fù)；或者 start 大于 end；或者 end 大于 s.length() 從以下版本開始：1.5 appendpublic StringBuffer append(char[] str) 將char 數(shù)組參數(shù)的字符串表示形式追加到此序列。按順序?qū)?shù)組參數(shù)中的字符追加到此序列的內(nèi)容中。此字符將增加該參數(shù)的長度。該方法的總體效果與以下操作過程的效果相同：先使用 String.valueOf(char[]) 方法將參數(shù)轉(zhuǎn)換為字符串，然后將所得字符串的字符追加到此字符序列。參數(shù)：str - 要追加的字符。返回：此對象的一個(gè)引用。appendpublic StringBuffer append(char[] str, int offset, int len) 將char 數(shù)組參數(shù)的子數(shù)組的字符串表示形式追加到此序列。將char 數(shù)組 str 中的字符按順序追加到此序列的內(nèi)容中，從索引 offset 開始。此字符的長度將增加 len 。該方法的最終效果與以下操作過程的效果相同：先使用 String.valueOf(char[]) 方法將參數(shù)轉(zhuǎn)換為字符串，然后將所得字符串的字符追加到此字符序列。參數(shù)：str - 要追加的字符。offset - 要追加的第一個(gè) char 的索引。len - 要追加的 char 的數(shù)量。返回：此對象的一個(gè)引用。appendpublic StringBuffer append(boolean b) 將boolean 參數(shù)的字符串表示形式追加到序列。參數(shù)將被轉(zhuǎn)換成字符串，就好象使用了 String.valueOf 方法一樣。然后，將所得字符串中的字符追加到此序列。參數(shù)：b - 一個(gè) boolean 值。返回：此對象的一個(gè)引用。另請參見：String.valueOf(boolean), append(java.lang.String)appendpublic StringBuffer append(char c) 將char 參數(shù)的字符串表示形式追加到此序列。參數(shù)將被追加到此序列。此序列的長度將增加 1 。該方法的最終效果與以下操作過程的效果相同：先使用 String.valueOf(char[]) 方法將參數(shù)轉(zhuǎn)換為字符串，然后將所得字符串的字符追加到此字符序列。指定者：接口Appendable 中的 append參數(shù)：c - 一個(gè) char 值。返回：此對象的一個(gè)引用。appendpublic StringBuffer append(int i) 將int 參數(shù)的字符串表示形式追加到此序列。參數(shù)將被轉(zhuǎn)換成字符串，就好象使用了 String.valueOf 方法一樣。然后，將所得字符串中的字符追加到此序列。參數(shù)：i - 一個(gè) int 值。返回：此對象的一個(gè)引用。另請參見：String.valueOf(int), append(java.lang.String)

Java的StringBuffer類中insert和append方法的區(qū)別insert能在字符串的任意位置添加，而append只能在末尾.
強(qiáng)烈建議這種問題去看JDK API文檔，看看就一目了然了

java語言：String類的concat方法與StringBuffer類的append方法區(qū)別？內(nèi)存狀態(tài)？首先我們先看幾個(gè)概念：1：在java內(nèi)部是對+進(jìn)行了重載，在處理String的過程中要?jiǎng)?chuàng)建一個(gè)StringBuffer對象，用StringBuffer對象的append方法對字符串進(jìn)行連接，最后調(diào)用toString方法返回String字符串。2： +和concat操作，是先開辟一個(gè)要拼接的字符串的空間，在和老字符串一起拼接成一個(gè)新的字符串，所以在堆內(nèi)存中是創(chuàng)建了三塊空間的；然后先來說1和2的區(qū)別：line1: 用的是+，+在底層是通過StringBuffer對象的append方法對字符串進(jìn)行連接，但是他也并不是直接添加的，我們看看他開辟了幾塊空間？“abc”“def”“ghi”,剛開始開辟了三塊堆內(nèi)存空間，執(zhí)行一次+,“abcdef”這是第四塊內(nèi)存空間，最后是最終結(jié)果“abcdefghi”開辟了第五塊堆內(nèi)存空間，然后其余的被回收。line2:同樣也是開辟了五塊堆內(nèi)存空間，concat()和+號的區(qū)別我們可以看下concat()源代碼：public String concat(String str) {int otherLen = str.length();if (otherLen == 0) {return this;}int len = value.length;/*copyOf數(shù)組復(fù)制,copyOf()的第二個(gè)自變量指定要建立的新數(shù)組長度，如果新數(shù)組的長度超過原數(shù)組的長度，則保留為默認(rèn)值null或0*/char buf[] = Arrays.copyOf(value, len + otherLen);//將字符從此字符串復(fù)制到目標(biāo)字符數(shù)組,len為數(shù)組中的起始偏移量str.getChars(buf, len);return new String(buf, true);}我們可以看到concat()方法是通過copyOf(),和getChars();兩個(gè)方法來拼接數(shù)組的。+在底層是通過StringBuffer對象的append方法對字符串進(jìn)行連接。最后是StringBuffer：StringBuffer使用時(shí)，只會開辟一塊內(nèi)存空間，使用append添加或delete刪除其內(nèi)容時(shí) ，也是在這一塊內(nèi)存空間中并不會生成多余的空間。所以速度是比較快的而String 每次生成對象都會對系統(tǒng)性能產(chǎn)生影響，特別當(dāng)內(nèi)存中無引用對象多了以后， JVM 的 GC 就會開始工作，對速度的影響一定是相當(dāng)大的。
請?jiān)敿?xì)說一下java中append()的方法.【stringbuffer】本視頻講解的是Java面向?qū)ο缶幊陶Z言中關(guān)于StringBuffer的知識，重點(diǎn)講解了通過該對象可以去追加字符串，同時(shí)也提到了方法鏈的編程風(fēng)格。
String和StringBuffer有什么區(qū)別？我在這里已經(jīng)有過類型的解答了

然后你問的是從回收的角度上來講的話,顯然StringBuffer對內(nèi)存的消耗要小的多,如果你用到了類似于我在上面那篇文章中舉的例子:
String s="Hello Baidu";
s=new String("Hello Baidu");
s=s.concat("!");
在內(nèi)存中會有兩個(gè)空間是沒有指向的,也不會被回收,因?yàn)樗鼈兌歼€不是Null.只有等到代碼結(jié)束的時(shí)候才會被回收.
在我們小的程序中這樣的開銷還可以忽略,但是大型的工程中,大量的開銷會對代碼運(yùn)行的速度帶來很大的影響.

而StringBuffer因?yàn)樗С中薷淖址闹?所以用它來作為應(yīng)用是安全的

如果我的回答還是沒有關(guān)系到你想問的地方,你可以給我留言,一起探討 =)

如果對您有幫助，請記得采納為滿意答案，謝謝！祝您生活愉快！

vaela

string和stringbuffer類的區(qū)別（1）String類對象為不可變對象，一旦你修改了String對象的值，隱性重新創(chuàng)建了一個(gè)新的對象，釋放原String對象，StringBuffer類對象為可修改對象，可以通過append()方法來修改值
（2）String類對象的性能遠(yuǎn)不如StringBuffer類。
關(guān)于以上具體解釋如下：
在java中有3個(gè)類來負(fù)責(zé)字符的操作。
1.Character 是進(jìn)行單個(gè)字符操作的，
2.String 對一串字符進(jìn)行操作。不可變類。
3.StringBuffer 也是對一串字符進(jìn)行操作，但是可變類。
String:
是對象不是原始類型.
為不可變對象,一旦被創(chuàng)建,就不能修改它的值.
對于已經(jīng)存在的String對象的修改都是重新創(chuàng)建一個(gè)新的對象,然后把新的值保存進(jìn)去.
String 是final類,即不能被繼承.
StringBuffer:
是一個(gè)可變對象,當(dāng)對他進(jìn)行修改的時(shí)候不會像String那樣重新建立對象
它只能通過構(gòu)造函數(shù)來建立,
StringBuffer sb = new StringBuffer();
注意:不能通過賦值符號對他進(jìn)行賦值.
sb = "welcome to here!";//error
對象被建立以后,在內(nèi)存中就會分配內(nèi)存空間,并初始保存一個(gè)null.向StringBuffer
中賦值的時(shí)候可以通過它的append方法.
sb.append("hello");
字符串連接操作中StringBuffer的效率要比String高:
String str = new String("welcome to ");
str += "here";
的處理步驟實(shí)際上是通過建立一個(gè)StringBuffer,讓侯調(diào)用append(),最后
再將StringBuffer toSting();
這樣的話String的連接操作就比StringBuffer多出了一些附加操作,當(dāng)然效率上要打折扣.
并且由于String 對象是不可變對象,每次操作Sting 都會重新建立新的對象來保存新的值.
這樣原來的對象就沒用了,就要被垃圾回收.這也是要影響性能的.

Java中String ， StringBuilder和StringBuffer的區(qū)別區(qū)別
1、StringBuffer 與 StringBuilder 中的方法和功能完全是等價(jià)的，
2、只是StringBuffer 中的方法大都采用了 synchronized 關(guān)鍵字進(jìn)行修飾，因此是線程安全的，
而 StringBuilder 沒有這個(gè)修飾，可以被認(rèn)為是線程不安全的。
3、在單線程程序下，StringBuilder效率更快，因?yàn)樗恍枰渔i，不具備多線程安全
而StringBuffer則每次都需要判斷鎖，效率相對更低

java中StringBuffer類的常用方法怎么用？StringBuffer sb = new StringBuffer("Hello ");sb.append("world");//在sb尾部追加一個(gè)字符串, 此時(shí)變成 Hello world;sb.charAt(1) ;//返回下標(biāo)為1的字符此處是 esb.insert(1,"d");//在 1 處插入新的字符串 d此時(shí)變?yōu)?Hedllo world;sb.reverse();//反轉(zhuǎn)字符此時(shí)變成dlrow olldeHsb.delete(1,2);//刪除字符串此時(shí)變?yōu)镠llo worldsb.replace(3,4,"new");//替換字符串從 3開始到4結(jié)束此時(shí)變?yōu)镠llnewworld全是手打的，望采納
Java中StringBuffer類append方法的使用

文章插圖

Java中append方法的作用是在一個(gè)StringBuffer對象后面追加字符串。例如StringBuffer s = new StringBuffer("Hello");s.append("World");則s的內(nèi)容是HelloWorld 。“拓展資料”：當(dāng)對字符串進(jìn)行修改的時(shí)候，需要使用 StringBuffer 和 StringBuilder 類。和 String 類不同的是，StringBuffer 和 StringBuilder 類的對象能夠被多次的修改，并且不產(chǎn)生新的未使用對象。StringBuilder 類在 Java 5 中被提出，它和 StringBuffer 之間的最大不同在于 StringBuilder 的方法不是線程安全的（不能同步訪問）。由于 StringBuilder 相較于 StringBuffer 有速度優(yōu)勢，所以多數(shù)情況下建議使用 StringBuilder 類。然而在應(yīng)用程序要求線程安全的情況下，則必須使用 StringBuffer 類。參考資料：Java StringBuffer--菜鳥教程
java中，StringBuffer類的toString的使用方法？StringBuffer sb = new StringBuffer("abcd") ;
sb.append("efg") ;
String str = sb.toString() ;
System.out.println(str) ;// out :"abcdefg"

使用StringBuffer的toString()方法，可以將StringBuffer轉(zhuǎn)換成String

JAVA中StringBuffer reverse()的用法StringBuffer s=new StringBuffer();
StringBuffer t=new StringBuffer();
t=s.reverse();
如果輸入s的字符串是“abc”則t的值為“cba”

java數(shù)據(jù)的使用方法？boolean java基本數(shù)據(jù)類型，有兩個(gè)值 true 和false；
1.直接賦值boolean b1=false;
2.由條件表達(dá)式賦值boolean b2=3>4;
3.由另一個(gè)boolean變量賦值boolean b3=b1;
4.由方法返回賦值boolean b4=list.ready();//假設(shè)ready方法返回一個(gè)boolean的話
程序中boolean為布爾類型變量

String類和StringBuffer類的區(qū)別String與StringBuffer的區(qū)別String:在String類中沒有用來改變已有字符串中的某個(gè)字符的方法，由于不能改變一個(gè)java字符串中的某個(gè)單獨(dú)字符，所以在JDK文檔中稱String類的對象是不可改變的。1）StringBuffer:StringBuffer類屬于一種輔助類，可預(yù)先分配指定長度的內(nèi)存塊建立一個(gè)字符串緩沖區(qū) 。這樣使用StringBuffer類的append方法追加字符比 String使用 + 操作符添加字符到一個(gè)已經(jīng)存在的字符串后面有效率得多。因?yàn)槭褂?+ 操作符每一次將字符添加到一個(gè)字符串中去時(shí)，字符串對象都需要尋找一個(gè)新的內(nèi)存空間來容納更大的字符串，這無凝是一個(gè)非常消耗時(shí)間的操作。添加多個(gè)字符也就意味著要一次又一次的對字符串重新分配內(nèi)存。使用StringBuffer類就避免了這個(gè)問題。2）StringBuffer是線程安全的，在多線程程序中也可以很方便的進(jìn)行使用，但是程序的執(zhí)行效率相對來說就要稍微慢一些。官方文檔說明：
string和stringbuffer類的區(qū)別1.三者在執(zhí)行速度方面的比較：StringBuilder > StringBuffer > String2.String <（StringBuffer，StringBuilder）的原因String：字符串常量StringBuffer：字符創(chuàng)變量StringBuilder：字符創(chuàng)變量從上面的名字可以看到，String是“字符創(chuàng)常量”，也就是不可改變的對象。對于這句話的理解你可能會產(chǎn)生這樣一個(gè)疑問，比如這段代碼：1 String s = "abcd";2 s = s+1;3 System.out.print(s);// result : abcd1

String，StringBuffer和StringBuilder的區(qū)別StringBuffer屬于線程安全，相對為重量級StringBuilder屬于非線程安全，相對為輕量級線程安全的概念：網(wǎng)絡(luò)編程中許多線程可能會同時(shí)運(yùn)行一段代碼。當(dāng)每次運(yùn)行結(jié)果和單獨(dú)線程運(yùn)行的結(jié)果是一樣的，叫做線程安全。為了達(dá)到線程安全的目的在一定程度上會降低程序的性能。所以在單線程中，StringBuilder的性能要比StringBuffer高。多線程為了線程安全需要采用StingBuffer 。其實(shí)在線程不考慮的情況下，要是程序?qū)π阅艿囊蟛桓?nbsp;，太在意這兩者的區(qū)別就沒有什么意義（個(gè)人理解）。

java中String與StringBuffer的具體該怎么用？String可以這樣用
String s = "I";
String o=s+"love"+"you";
StringBuffer可以這樣用;
比如你在查詢語句動態(tài)的給參數(shù)查詢時(shí)可以用他拼湊HQL語句
StringBuffer sb = new StringBuffer("FROM USER AS A WHERE 1=1");
sb.append(" AND A.userName='");
sb.append(userName);
sb.append("'");
sb.append(" AND A.age='");
sb.append(age);
sb.append("'");

StringBuffer是什么意思在java中。其實(shí)就是string類型的升級版其好處節(jié)省內(nèi)存空間效率比string的單個(gè)拼接效率高
字符串的拼接：
String a="b";
a=a+"c";
System.out.println(a);//輸出bc 這理念有a對象還有第二個(gè) 又是一個(gè)對象兩個(gè)對象
StringBuffer a1=new StringBuffer();
a1.append("b");
a1.append("c");
System.out.println(a1);//輸出bc 一個(gè)對象 a1

java里面有了stringbuffer為什么還要有string如果字符串修改不頻繁string在編寫時(shí)還是很方便的,而且string是基礎(chǔ)類型,不能隨意刪.
還有,下面兩個(gè)類都不是string的子類.
stringbuilder適合單線程頻繁修改字符串.
stringbuffer適合多線程修改字符串,因?yàn)檫@個(gè)方法在修改字符串時(shí)會檢查線程鎖,可以保證一個(gè)線程在修改字符串時(shí),其他線程不能對同一個(gè)字符串進(jìn)行修改.
上述內(nèi)容,在java與c#中都一樣.

有了stringbuffer ，為什么還要string他們的區(qū)別是很大的,它們是兩個(gè)獨(dú)立的類,可以這么說吧,除了名字有些相似,完全不相干.String類是不可改變的，如果你更改了String類的實(shí)例，那么以前的就“不存在了” ，所指向的是一個(gè)新的實(shí)例。而StringBuffer類是可以更改的。
看如下例子，體會這一點(diǎn)：
String s1="Hello";
String s2="Hello";
if(s1==s2)
System.out.println("Equal");
else
System.out.println("Not equla");
這個(gè)程序片斷將輸出Equal,原因是String類的實(shí)例是不能更改的.在生成第2個(gè)實(shí)例時(shí)它發(fā)現(xiàn)在緩沖池中已經(jīng)有了"Hello"字符串,于是它就直接索引到這個(gè)字符串.
然而如果,你將第二行代碼改為:
String s2 = new String("Hello");
再運(yùn)行結(jié)果將是Not equal,因?yàn)楦鼡Q了一個(gè)構(gòu)造器形式,在生成第二個(gè)實(shí)例時(shí),它就不在緩沖池中索引了,而是直接在內(nèi)存中構(gòu)造這樣一個(gè)對象.因此,其句柄的值是不同的.
也就是說,當(dāng)你更改了String類的實(shí)例,那么其句柄索引的將是在Heap Memory的另外一個(gè)位置的對象,以前的就不能再索引到了.
但是,StringBuffer類卻不是如此,如果你更改了它的實(shí)例,但是在Heap Memory的緩沖池中,索引的是同一個(gè)實(shí)例.即更改了實(shí)例,但句柄的只是不變的,它是可以更改的!

連接字符串的時(shí)候?yàn)槭裁从肧tringBuffer而不用StringStringBuffer是可以改變的字符串，而String是不可改變的。每次使用System.String類中的方法之一時(shí)，都要在內(nèi)存中創(chuàng)建一個(gè)新的字符串對象，就要為該對象分配新的空間。當(dāng)要對字符串重復(fù)修改時(shí)，創(chuàng)建新的String對象相關(guān)的系統(tǒng)開銷很大，就是要修改字符串而不創(chuàng)建新的對象，則用StringBuffer 。

StringBuffer明明比String好,為什么我們工作中還是用String？1.常量池里的string對象可以共享，stringbuffer必須每次在堆上new2.String的+操作，會自動被編譯器優(yōu)化為stringbuilder（jdk1.5開始，如果我沒有記錯(cuò)）3.String的+操作比append更為直觀

不是說StringBuffer類可以替代String類嗎。。。怎么StringBuffer不能用toCharArray方法呢API 上有。

public void getChars(int srcBegin,
int srcEnd,
char[] dst,
int dstBegin)將字符從此序列復(fù)制到目標(biāo)字符數(shù)組 dst 。要復(fù)制的第一個(gè)字符在索引 srcBegin 處；要復(fù)制的最后一個(gè)字符在索引 srcEnd-1 處。要復(fù)制的字符總數(shù)為 srcEnd-srcBegin 。要復(fù)制到 dst 子數(shù)組的字符從索引 dstBegin 處開始，結(jié)束于以下索引：

dstbegin + (srcEnd-srcBegin) - 1

參數(shù)：
srcBegin - 從此偏移量處開始復(fù)制。
srcEnd - 在此偏移量處停止復(fù)制。
dst - 用來保存復(fù)制數(shù)據(jù)的數(shù)組。
dstBegin - dst 中的偏移量。
拋出：
NullPointerException - 如果 dst 為 null 。
IndexOutOfBoundsException - 如果以下任意一項(xiàng)為 true：
srcBegin 為負(fù)
dstBegin 為負(fù)
srcBegin 參數(shù)大于 srcEnd 參數(shù) 。
srcEnd 大于 this.length() 。
dstBegin+srcEnd-srcBegin 大于 dst.length
-------------------------------------------------------------------------------
先定義好數(shù)組：
StringBuffer sb = ......;
char[] c = new char[sb.length()];
sb.getChars(0, c.length, c, 0);