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类就避免了这个问题.