javastringbuffer
Ⅰ java 中的StringBuffer是什麼東西，是拿來干什麼的。
你可以看 它與String的區別 主擾春要用於拼接字元串 是一個可變長的字元竄
1、StringBuffer對象的初始化
StringBuffer對象的初始化不像String類的初始化一樣，Java提供的有特殊的語法，而通常情況下一般使用構造方法進行初始化。
例如：
StringBuffer s = new StringBuffer();
這樣初始化出的StringBuffer對象是一個空的對象。
如果需要創建帶有內容的StringBuffer對象，則可以使用衡卜：
StringBuffer s = new StringBuffer(「abc」);
這樣初始化出的StringBuffer對象的內容就是字元串」abc」。
需要注意的是，StringBuffer和String屬於不同的類型，也不能直接進行強制類型轉換，下面的代碼都是錯誤的：
StringBuffer s = 「abc」; //賦值類型不匹配
StringBuffer s = (StringBuffer)」abc」; //不存在繼承關系，無法進行強轉
StringBuffer對象和String對象之間的互轉的代碼如下：
String s = 「abc」;
StringBuffer sb1 = new StringBuffer(「123」);
StringBuffer sb2 = new StringBuffer(s); //String轉換為StringBuffer
String s1 = sb1.toString(); //StringBuffer轉換為String
2、StringBuffer的常用方法
StringBuffer類中的方法主要偏重於對於字元串的變化，例如追加、插入和刪除等，這個也是StringBuffer和String類的主要區別。
a、append方法
public StringBuffer append(boolean b)
該方法的作用是追加內容到當前StringBuffer對象的末尾，類似於字元串的連接。調用該方法以後，StringBuffer對象的內容也發生改變，例如：
StringBuffer sb = new StringBuffer(「abc」);
sb.append(true);
則對象sb的值將變成」abctrue」。
使用該方法進行字元串的連接，將比String更加節約內容，例如應用於資料庫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)
該方法的作用是刪除指定位置的字元，然後將剩餘的內容形成新的字元串。例如：
StringBuffer sb = new StringBuffer(「Test」);
sb. deleteCharAt(1);
該代碼的作用刪除字元串對象sb中索引值為1的字元，也就是刪除第二個字元，剩餘的內容組成一個新的字元串。所以對象sb的值變為」Tst」。
還存在一個功能類似的delete方法：
public StringBuffer delete(int start,int end)
該方法的作用是刪除指定區間以內的所有字元，包含start，不包含end索引值的區間。例如：
StringBuffer sb = new StringBuffer(「TestString」);
sb. delete (1,4);
該代碼的作用是刪除索引值1(包括)到索引值4(不包括)之間的所有字元，剩餘的字元形成新的字元串。則對象sb的值是」TString」。
c、insert方法
public StringBuffer insert(int offset, boolean b)
該方法的作用是在StringBuffer對象中插入內容，然後形成新的字元串。例如：
StringBuffer sb = new StringBuffer(「TestString」);
sb.insert(4,false);
該示例代碼的作用是在對象sb的索引值4的位置插入false值，形成新的字元串，則執行以後對象sb的值是」TestfalseString」。
d、reverse方法
public StringBuffer reverse()
該方法的作用是將StringBuffer對象中的內容反轉，然後形成新的字元串。例如：
StringBuffer sb = new StringBuffer(「abc」);
sb.reverse();
經過反轉以後，對象sb中的內容將變為」cba」。
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對象的中存儲空間縮小到和字元串長度一樣的長度，減少空間的浪費。
Ⅱ java中StringBuffer類的常用方法有有哪些
StingBuffer類常用的一些方法有：
append( ),表示將括弧里的某種數據類型的變數插入某一序列中
charAt( ),返回此序列中指定索引處的 char 值
toString( ),返回此序列中數據的字元串表示形式。
subString( ), 返回一個新的 String，它包含此鎮畢序列當前所包含的字元子序列。
delete( ),移除此序列的子字元串中的字元。
deletecharAt (), 移除此序列指定位置的 char。
insert( ),表示將括弧里的某種數據類型的變數插入某一序列中
reverse( ),將此字元序列用其反轉形式取代
setCharAt(int index, char ch ),將給定索引處的字元設置為 ch。
trimToSize (),嘗試減少用於字元序列的存儲空間。
StringBufferappend(boolean b)
將 boolean 參數的字元串表示形式追加到序列。 StringBufferappend(char c)
將 char 參數的字元串表示形式追加到此序列。 StringBufferappend(char[] str)
將 char 數組參數的字元串表示形式追加到此序列。 StringBufferappend(char[] str, int offset, int len)
將 char 數組參數的子數組的字元串表示形式追加到此序列。 StringBufferappend(CharSequence s)
將指定的 CharSequence 追加到該序列祥臘。 StringBufferappend(CharSequence s, int start, int end)
將指定 CharSequence 的子序列追加到此序列。 StringBufferappend(double d)
將 double 參數的字元串表示形式追加到此序列。 StringBufferappend(float f)
將 float 參數的字元串表示形式追加到此序列。 StringBufferappend(int i)
將 int 參數的字元串表示形式追加到此序列。 StringBufferappend(long lng)
將 long 參數的字元串表示形式追加到此序列。 StringBufferappend(Object obj)
追加 Object 參數的字元串表示形式。 StringBufferappend(String str)
將指定的字元串追加到此字元序列。 StringBufferappend(StringBuffer sb)
將指定的 StringBuffer 追加到御宴芹此序列中。 StringBufferappendCodePoint(int codePoint)
將 codePoint 參數的字元串表示形式追加到此序列。 intcapacity()
返回當前容量。 charcharAt(int index)
返回此序列中指定索引處的 char 值。 intcodePointAt(int index)
返回指定索引處的字元（統一代碼點）。 intcodePointBefore(int index)
返回指定索引前的字元（統一代碼點）。 intcodePointCount(int beginIndex, int endIndex)
返回此序列指定文本范圍內的統一代碼點。 StringBufferdelete(int start, int end)
移除此序列的子字元串中的字元。 StringBufferdeleteCharAt(int index)
移除此序列指定位置的 char。 voidensureCapacity(int minimumCapacity)
確保容量至少等於指定的最小值。 voidgetChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
將字元從此序列復制到目標字元數組 dst。 intindexOf(String str)
返回第一次出現的指定子字元串在該字元串中的索引。 intindexOf(String str, int fromIndex)
從指定的索引處開始，返回第一次出現的指定子字元串在該字元串中的索引。 StringBufferinsert(int offset, boolean b)
將 boolean 參數的字元串表示形式插入此序列中。 StringBufferinsert(int offset, char c)
將 char 參數的字元串表示形式插入此序列中。 StringBufferinsert(int offset, char[] str)
將 char 數組參數的字元串表示形式插入此序列中。 StringBufferinsert(int index, char[] str, int offset, int len)
將數組參數 str 的子數組的字元串表示形式插入此序列中。 StringBufferinsert(int dstOffset, CharSequence s)
將指定 CharSequence 插入此序列中。 StringBufferinsert(int dstOffset, CharSequence s, int start, int end)
將指定 CharSequence 的子序列插入此序列中。 StringBufferinsert(int offset, double d)
將 double 參數的字元串表示形式插入此序列中。 StringBufferinsert(int offset, float f)
將 float 參數的字元串表示形式插入此序列中。 StringBufferinsert(int offset, int i)
將 int 參數的字元串表示形式插入此序列中。 StringBufferinsert(int offset, long l)
將 long 參數的字元串表示形式插入此序列中。 StringBufferinsert(int offset, Object obj)
將 Object 參數的字元串表示形式插入此字元序列中。 StringBufferinsert(int offset, String str)
將字元串插入此字元序列中。 intlastIndexOf(String str)
返回最右邊出現的指定子字元串在此字元串中的索引。 intlastIndexOf(String str, int fromIndex)
返回最後一次出現的指定子字元串在此字元串中的索引。 intlength()
返回長度（字元數）。 intoffsetByCodePoints(int index, int codePointOffset)
返回此序列中的一個索引，該索引是從給定 index 偏移 codePointOffset 個代碼點後得到的。 StringBufferreplace(int start, int end, String str)
使用給定 String 中的字元替換此序列的子字元串中的字元。 StringBufferreverse()
將此字元序列用其反轉形式取代。 voidsetCharAt(int index, char ch)
將給定索引處的字元設置為 ch。 voidsetLength(int newLength)
設置字元序列的長度。 CharSequencesubSequence(int start, int end)
返回一個新的字元序列，該字元序列是此序列的子序列。 Stringsubstring(int start)
返回一個新的 String，它包含此字元序列當前所包含的字元子序列。 Stringsubstring(int start, int end)
返回一個新的 String，它包含此序列當前所包含的字元子序列。 StringtoString()
返回此序列中數據的字元串表示形式。 voidtrimToSize()
嘗試減少用於字元序列的存儲空間。
Ⅲ StringBuffer是什麼意思 在java中。
StringBuffer和String一樣，都用來表示字元串。但腔配是其內部實現機制和String不同，對兄圓喊StringBuffer對象的每一次修改都會改變其自身對象，而不是像String一樣生成一個新的對象，所以StringBuffer在內存控制羨野上要優於String。
Ⅳ 在JAVA中怎麼清空StringBuffer變數內容
StringBuffersb=newStringBuffer();
...
sb.delete(0,sb.length);//刪除所有的和臘數據
//sb=newStringBuffer();//或者陪芹重新初始化，蘆棚畢數據為空
御坂認真的回答道。
Ⅳ Java中StringBuffer類append方法的使用
Java中append方法的作用是在一個StringBuffer對象後面追加字元串。
例如StringBuffer s = new StringBuffer("Hello");s.append("World");
則s的內容是HelloWorld。
「拓展資料」：
當對字元串進行修改的時候，需要使用 StringBuffer 和 StringBuilder 類。
和 String 類不同的是，StringBuffer 和 StringBuilder 類的對象能夠被多次的修改，並且不產生新的未使用對象。
StringBuilder 類在 Java 5 中被提出，它和 StringBuffer 之間的最大不同在於 StringBuilder 的方法不是線程安全的（不能同步訪問）。
由於 StringBuilder 相較於 StringBuffer 有速度優勢，所以多數情況下建議使用 StringBuilder 類。然而在應用程序要求線程安全的情況下，則必須使用 StringBuffer 類。
Ⅵ java中String與StringBuffer的具體該怎麼用
去我的網路空間 裡面有介紹這兩個的用法。簡單點就是String相比StringBuffer消耗資源。一個是不可變的 一個是可運祥變的。
一般數據量小的時候使用String！
關於java的字元串處理我們一般使用String類和StringBuffer類
那麼String類和StringBuffer類的區別在什麼地方呢?
與包裝類相似，String類是不可以改變的，從而不能修改字元串的值，所以必須創建一個新的字元串來存放，每次都重新開辟了一個內存空間。
如果字元串較少的話我們可以使用String 類，如果文件有幾百成千個位元組又會怎麼樣呢.
相反，我們提供另一個類Stingbuffer 來對字元串進行操作。
String類常用方法：
char charAt(int index); 返回index索引位置的字元
int length（）; 返回字元串的長度。
String substring（int beginindex，int endindex） 返回一個新的字元串，其值是beginindex索引位置到endindex索引位置。
String trim（）； 去除字元串兩邊的空格，並返回一個新的字元串。
String toLowerCase(); 將字元串中的所以大寫字母轉換成小寫字母，已有大寫字母則不需要轉換，並返回一個新旁孝搏的字元串。
String toUpperCase（）;String toLowerCase(); 將字元串中的所以小『寫字母轉換慎檔成小寫字母，已有小寫字母則不需要轉換，並返回一個新的字元串。
boolean equals（String str）;本對象中的字元串與str對象字元串進行比較（區分大小寫） 返回一個boolean值
String replace(char oldChar, char newChar);將舊的字元串（oldChar）換成新的字元串（newChar）
String類方法：
主要方法
append（）;向字元串末尾添加數據，而不像String類重新開辟空間存放新的內容
insert();根據方法的重載傳遞不同的參數，在指定的位置對字元串進行插入子字元串。
例：
String str = "how ";
str += "are ";
str +="you";
如果我們列印str的最終結果是how are you 是我們所期望的，內存裡面的變化：
how
how are
how are you
String類使用重載加法運算符，在字元串表中創建新的條目，上面一共創建了三條。
當處理的字元串過多時，上面的做法就很耗費內存。
StringBuffer str = new StringBuffer("how");
//向str末尾添加字元串
str.append("are ");
str.append( "you");
將需要處理字元串交給StringBuffer類處理 ，
每個字元串緩沖區都有一定的容量。只要字元串緩沖區所包含的字元序列的長度沒有超出此容量，
就無需分配新的內部緩沖區數組。如果內部緩沖區溢出，則此容量自動增大。而不是重新聲明新的對象
這樣的話就不會耗費內存!
Ⅶ JAVA Stringbuffer對象怎麼輸出
以前寫的小例子看下你是否有幫助：
importjava.io.IOException;
importjava.io.*;
publicclassCopy2{
publicstaticvoidmain(Stringargs[])throwsIOException{
Stringstr=null;
FileReaderaa=newFileReader("D:/aa.txt");
BufferedReaderbb=newBufferedReader(aa);
FileWritertofile=newFileWriter("D:/bb.txt");
BufferedWriterout=newBufferedWriter(tofile);
while((str=bb.readLine())!=null){
out.write(str);
out.newLine();
}
行蠢out.close();
bb.close();
枝判aa.close();
猛帶改tofile.close();
}
}
Ⅷ 請問java Stringbuffer在什麼情況下用到
一般在凱鬧字元串拼伍念接時使用
具體代碼如下：
publicclassBaiTest{
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Stringa="aaaa";
Stringb="bbbbbb";
StringBufferab=newStringBuffer();
ab.append(a).append("-").append(b);
System.out.println(ab.toString());
}
}執行結果：盯橘罩
Ⅸ 在Java中怎樣把StringBuffer中的字元串寫入到文件
使用Java中的File類，url為文件的絕對地址，str為輸入的字元串內容。
代碼如下圖所示：
importjava.io.FileWriter;
importjava.io.IOException;
publicclassTestFile{
publicstatic鋒笑voidmain(String[]args)山讓{
StringBuffersb=newStringBuffer();
sb.append("12345 ");
sb.append("abcde ");
sb.append("123.abc");
try{
FileWriterfw=newFileWriter("c:/test.txt"銀唯含);
fw.write(sb.toString());
fw.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
Ⅹ java中String 和StringBuffer有什麼區別
String和StringBuffer的區別，網上資料可以說是數不勝數，但是看到這篇文章，感覺裡面做的小例子很有代表性，所以轉一下，並自己做了一點總結。
在java中有3個類來閉啟負責字元的操作。
1.Character 是進行單個字元操作的
2.String 對一串字元進行操作。不可變類。
3.StringBuffer 也是對一串字元進行操作，但是可變類。
String:
是對象不是原始類型.
為不可變對象,一旦被創建,就不能修改它的值.
對於已經存在的String對象的修改都是重新創建一個新的對象,然後把新的值保存進去讓高.
String 是final類,即不能被繼承.
StringBuffer:
是一個可變對象,當對他進行修改的時候不會像String那樣重新建立對象
它只能通過構造函數來建立,
StringBuffer sb = new StringBuffer();
note:不能通過付值符號對他進行付值.
sb = "welcome to here!";//error
對象被建立以後,在內存中就會分配內存空間,並初始保存一個null.向StringBuffer
中付值的時候可以通過它的append方法.
sb.append("hello");
字元串連接操作中StringBuffer的效率要比String高:
String str = new String("welcome to ");
str += "here";
的處理坦態尺步驟實際上是通過建立一個StringBuffer,然後調用append(),最後
再將StringBuffer toSting();
這樣的話String的連接操作就比StringBuffer多出了一些附加操作,當然效率上要打折扣.
並且由於String 對象是不可變對象,每次操作Sting 都會重新建立新的對象來保存新的值.
這樣原來的對象就沒用了,就要被垃圾回收.這也是要影響性能的.
看看以下代碼：
將26個英文字母重復加了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);
可惜我的計算機不是超級計算機，得到的結果每次不一定一樣一般為 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);
得到的結果為 16 有時還是 0
所以結論很明顯，StringBuffer 的速度幾乎是String 上萬倍。當然這個數據不是很准確。因為循環的次數在100000次的時候，差異更大。不信你試試。
根據上面所說：
str += "here";
的處理步驟實際上是通過建立一個StringBuffer,讓侯調用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);
平均執行時間為46922左右，也就是46秒。
總結: 如果在程序中需要對字元串進行頻繁的修改連接操作的話.使用StringBuffer性能會更高
本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/yirentianran/archive/2008/09/03/2871417.aspx
--------------------------------------------------------------------------------------------------------------------------------------------
另外一段網上對String與StringBuffer區別的註解:
String和StringBuffer
String 是不可以變的字元串.
StringBuffer 是可變的字元串.
對StringBuffer進行操作,是在原來的對象之上進行改變. 而對String進行操作,是創建新的對象。
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);
}
}
輸出結果
javajavaC
String實例化以後所有的屬性都是final的，而StringBuffer確不是，這就是可變與不可變。
這是因為第七行text = text.append ("C")，append方法會改變text中的值,而text與textBuffer指向的地址是相同的。因此會列印javaC
再舉個例子：
String a = "a"; //假設a指向地址0x0001
a = "b"; //重新賦值後a指向地址0x0002，但0x0001地址中保存的"a"依舊存在，但已經不再是a所指向的。
因此String的操作都是改變賦值地址而不是改變值操作。
具體：
String:在String類中沒有用來改變已有字元串中的某個字元的方法，由於不能改變一個java字元串中的某個單獨字元，所以在JDK文檔中稱String類的對象是不可改變的。然而，不可改變的字元串具有一個很大的優點:編譯器可以把字元串設為共享的。
StringBuffer:StringBuffer類屬於一種輔助類，可預先分配指定長度的內存塊建立一個字元串緩沖區。這樣使用
StringBuffer類的append方法追加字元比String使用 + 操作符添加字元到一個已經存在的字元串後面有效率得多。因為使用 + 操作符每一次將字元添加到一個字元串中去時，字元串對象都需要尋找一個新的內存空間來容納更大的字元串，這無凝是一個非常消耗時間的操作。添加多個字元也就意味著要一次又一次的對字元串重新分配內存。使用StringBuffer類就避免了這個問題.