stringbuffer _生活经验

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转换为StringBufferString s1 = sb1.toString();//StringBuffer转换为String2、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中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类就避免了这个问题.

java中StringBuffer是什么，怎么用？public final class StringBufferextends Objectimplements Serializable, CharSequence
线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容为 "start" 的字符串缓冲区对象，则此方法调用z.append("le") 会使字符串缓冲区包含 "startle"，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含 "starlet" 。
通常，如果 sb 引用 StringBuilder 的一个实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。
当发生与源序列有关的操作（如源序列中的追加或插入操作）时，该类只在执行此操作的字符串缓冲区上而不是在源上实现同步。
每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即 StringBuilder 。与该类相比，通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

基本方法append(),insert(),substring(),delete(),replace(),indexOf()这种,具体就查手册吧，一大堆方法呢

请问java Stringbuffer在什么情况下用到？一般在字符串拼接时使用具体代码如下：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());}}执行结果：
JAVA中StringBuffer与StringBuilder、String的区别是什么？java中String、StringBuffer、StringBuilder是编程中经常使用的字符串操作类。
1.可变与不可变
String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。
private final char value[];
StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。
char[] value;

2.是否多线程安全
String中的对象是不可变的，也就可以理解为常量，显然线程安全。
AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。
StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。看如下源码：
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并没有对方法进行加同步锁，所以是非线程安全的。

3.StringBuilder与StringBuffer共同点
StringBuilder与StringBuffer有公共父类AbstractStringBuilder(抽象类) 。
抽象类与接口的其中一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。
StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...) 。只是StringBuffer会在方法上加synchronized关键字，进行同步。
最后，如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer 。

stringbuffer与stringbuilder的区别?java中String、StringBuffer、StringBuilder是编程中经常使用的字符串类，他们之间的区别也是经常在面试中会问到的问题。现在总结一下，看看他们的不同与相同。
1.可变与不可变
String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。
private final char value[];
StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。
char[] value;
2.是否多线程安全
String中的对象是不可变的，也就可以理解为常量，显然线程安全。
AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。
StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。看如下源码：

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并没有对方法进行加同步锁，所以是非线程安全的。
3.StringBuilder与StringBuffer共同点
StringBuilder与StringBuffer有公共父类AbstractStringBuilder(抽象类) 。
抽象类与接口的其中一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。
StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...) 。只是StringBuffer会在方法上加synchronized关键字，进行同步。
最后，如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer 。

Java中String和StringBuffer的区别?String 不是简单类型，而是一个类，它被用来表示字符序列。字符本身符合 Unicode 标准，其初始化方式有两种。
如：String greeting=“Good Morning! \n”;
String greeting=new String(=“Good Morning! \n”);
String的特点是一旦赋值，便不能更改其指向的字符对象，如果更改，则会指向一个新的字符对象。

StringBuffer是一个具有对象引用传递特点的字符串对象。
StringBuffer对象可以调用其方法动态的进行增加、插入、修改和删除操作，且不用像数组那样事先指定大小，从而实现多次插入字符，一次整体取出的效果，因而操作字符串非常灵活方便。
一旦通过StringBuffer生成最终想要的字符串，就可调用它的toString方法将其转换为一个String对象

String和StringBuffer有什么区别?。?/h3>StringBuffer是一个具有对象引用传递特点的字符串对象。StringBuffer对象可以调用其方法动态的进行增加、插入、修改和删除操作，且不用像数组那样事先指定大小，从而实现多次插入字符，一次整体取出的效果，因而操作字符串非常灵活方便。一旦通过StringBuffer生成最终想要的字符串，就可调用它的toString方法将其转换为一个String对象追问： StringBuffer调用它的toString方法指向一个地址，最后还是变成了一个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：两个类的 substring( int beginIndex, int endIndex)方法都是用来截取字符串，且范围都是从beginIndex 开始，到 endIndex--1 为止。不同： 1: String 类是不可变类， StringBuffer 类是可变类 String 类提供的比如 substring，replace 等方法都不会更改字符串内容，实际上是创建一个方法所浮于特性的新字符串。返回一个改变后内容的新字符串。StringBuffer 的 appeng(),等方法都会改变字符缓冲区中的字符串内容。2：String 类覆盖了Object类的 equals（）方法 StringBuffer类没有覆盖 3：都覆盖了Object()类的 toString() 方法，实现不一样 String类的toString() 方法返回当前String实例本身的引用。StringBuffer类的toString方法返回一个以当前StringBuffer的缓冲区中的所有字符串为内容的新的 String对象的引用。4： String 对象可以用操作符 "+ " 进行连接 StringBuffer 不能追问：我懂了String sql =“hello word”；相当于String创建以后就有了空的字符，然后将字符串“hello word”赋值给它，得到新的字符串。StringBuffer类的toString方法类似于把创建后的空字符串改变成新的字符串，没有重新赋值。可以这样理解吗？回答：简单点说用StringBuffer主要是为了对字符进行增加、插入、修改和删除操作，而String 是操作完成后用来存储字符的。就好像说一块固态（String）的金砖，你想改变的的形状就的先融化成液态（StringBuffer），等形状确定以后再变成固态（String）。这个比方并不是很恰当，不过应该更好一点理解。补充：你的理解只能说没错，却也不完全正确。追问：感谢！回答：不客气，互相交流一下，我现在都很少用Java了，改行学C++

请问java中的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 都会重新建立新的对象来保存新的值.这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.

JAVA的String类和StringBuffer两个类的区别StringBuffer类和String一样，也用来代表字符串，只是由于StringBuffer的内部实现方式和String不同，所以StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。所以在实际使用时，如果经常需要对一个字符串进行修改，例如插入、删除等操作，使用StringBuffer要更加适合一些。在StringBuffer类中存在很多和String类一样的方法，这些方法在功能上和String类中的功能是完全一样的。但是有一个最显著的区别在于，对于StringBuffer对象的每次修改都会改变对象自身，这点是和String类最大的区别。另外由于StringBuffer是线程安全的，所以在多线程程序中也可以很方便的进行使用，但是程序的执行效率相对来说就要稍微慢一些。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转换为StringBufferString s1 = sb1.toString();//StringBuffer转换为String2、StringBuffer的常用方法StringBuffer类中的方法主要偏重于对于字符串的变化，例如追加、插入和删除等，这个也是StringBuffer和String类的主要区别。a、append方法public StringBuffer append(boolean b)该方法的作用是追加内容到当前StringBuffer对象的末尾，类似于字符串的连接。调用该方法以后，StringBuffer对象的内容也发生改变，例如：StringBuffe 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对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费。总之，在实际使用时，String和StringBuffer各有优势和不足，可以根据具体的使用环境，选择对应的类型进行使用。
Java中String和StringBuffer的区别1.就是一个变量和常量的关系。StringBuffer对象的内容可以修改；而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象。2.StringBuffer的内部实现方式和String不同，StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。所以在实际使用时，如果经常需要对一个字符串进行修改，3.插入、删除等操作，使用StringBuffer要更加适合一些。String对象创建以后就不能修改了，除非让String类型的引用指向另一个String对象。
Java中String和StringBuffer的区别是什么？1.就是一个变量和常量的关系。StringBuffer对象的内容可以修改；而String对象一旦产生后就不可以被修改，重新赋值其实是两个对象。2.StringBuffer的内部实现方式和String不同，StringBuffer在进行字符串处理时，不生成新的对象，在内存使用上要优于String类。所以在实际使用时，如果经常需要对一个字符串进行修改， 3.插入、删除等操作，使用StringBuffer要更加适合一些。String对象创建以后就不能修改了，除非让String类型的引用指向另一个String对象。
java中String和StringBuffered有什么区别?楼上别在摆渡里随便搞一段来糊弄人拉其实String和StringBuffer很简单：在String中有“池”这么一个概念，不知道楼主知道不知道，比如说String str="hello" 这句话创建了两个对象，一个是str这个对象，另外一个就是在池中创建的"hello"，接着str="helloMan"，使用这句话的时候，虚拟机首先会去池中找有没有"helloMan"字符串，如果有的话，就拿池中的来用，没有的话就和之前那句代码一样处理，这样一来，无论从效率上还是内存消耗上来讲都是比较大的，因为String类是final类型的（这个可以参考API或者源代码）。而StringBuffer就不一样了，是JAVA专门用来处理字符串拼接问题的一个类，StringBuffer sb="a"; sb="ab"; 第二句代码就不会创建新的实例了，而是在a的后面加了一个b 。以前我做过一个测试，就是测试一下String类和StringBuffer在处理字符串拼接的时候的效率问题，结果证明StringBuffer的处理速度是String类处理速度的1000倍，也就是说StringBuffer处理一秒的事情String类要处理16分钟还多。

说明string和stringbuffer的优缺点，并举例说明？1. String 类String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且大量浪费有限的内存空间。String a = "a"; //假设a指向地址0x0001a = "b";//重新赋值后a指向地址0x0002，但0x0001地址中保存的"a"依旧存在，但已经不再是a所指向的,a 已经指向了其它地址。因此String的操作都是改变赋值地址而不是改变值操作。2. StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量。StringBuffer buf=new StringBuffer(); //分配长16字节的字符缓冲区StringBuffer buf=new StringBuffer(512); //分配长512字节的字符缓冲区StringBuffer buf=new StringBuffer("this is a test")//在缓冲区中存放了字符串，并在后面预留了16字节的空缓冲区。3.StringBufferStringBuffer和StringBuilder类功能基本相似，主要区别在于StringBuffer类的方法是多线程、安全的，而StringBuilder不是线程安全的，相比而言， StringBuilder类会略微快一点。对于经常要改变值的字符串应该使用StringBuffer和StringBuilder类。4.线程安全StringBuffer 线程安全StringBuilder 线程不安全5.速度一般情况下,速度从快到慢:StringBuilder>StringBuffer>String,这种比较是相对的，不是绝对的。6.总结（1）.如果要操作少量的数据用 = String（2）.单线程操作字符串缓冲区下操作大量数据 = StringBuilder（3）.多线程操作字符串缓冲区下操作大量数据 = StringBuffer

StringBuffer是什么?StringBuffer类常用方法简介StringBuffer类用于处理可变的字符串，它提供修改字符串的方法。（1）构造方法：a. StringBuffer s0=new StringBuffer();分配了长16字节的字符缓冲区b. StringBuffer s1=new StringBuffer(512);分配了512字节的字符缓冲区c. StringBuffer s2=new StringBuffer("You are good!"); 在字符缓冲区中存放字符串"Happy new year！" ，另外，后面再留了16字节的空缓冲区。（2）常用方法：a．字符设置和替换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．在字符串末尾添加内容（Append方法）StringBuffer s=newStringBuffer("we");char d={"l","c","o","m","e"};s.append(d);则s为"welcome" 。d.转换为不变字符串:toString() 。e.获取字符串的长度: length()StringBuffer s = new StringBuffer("www");int i=s.length();f.获取字符串的容量 s.capacity();g.重新设置字符串容量的大?。篹nsureCapacity() s.ensureCapacity(100);h.设置字符串缓冲区的大小 s.setlength(10); 如果用小于当前字符串长度的值调用setlength()方法，则新长度后面的字符将丢失。i.将字符串的子字符串复制给数组 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.字符串反转 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下标开始以后的字符串 substring(int start,int end) //返回从start到 end-1字符串

StringBuffer sb=new StringBuffer("内容")构造一个字符串sb ，内容为“内容”,相当于String sb= new String("内容");只是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方法的使用参数将被转换成字符串，就好象使用了 String.valueOf 方法一样。然后，将所得字符串中的字符追加到此序列。参数：obj - 一个 Object 。返回：此对象的一个引用。另请参见：String.valueOf(java.lang.Object), append(java.lang.String)appendpublic StringBuffer append(String str) 将指定的字符串追加到此字符序列。按顺序追加 String 变量中的字符，使此序列增加该变量的长度。如果 str 为 null，则追加 4 个字符 "null" 。假设此字符序列的长度在执行 append 方法前为 n 。如果 k 小于 n，则新字符序列中索引 k 处的字符等于原序列中索引 k 处的字符；否则它等于参数 str 中索引 k-n 处的字符。参数：str - 一个 string 。返回：此对象的一个引用。appendpublic StringBuffer append(StringBuffer sb) 将指定的 StringBuffer 追加到此序列中。按顺序将 StringBuffer 参数中的字符追加到此 StringBuffer 中，并使 StringBuffer 在长度上增加该参数的长度。如果 sb 为 null ，则将 4 个 "null" 字符追加到此 StringBuffer 中。在执行 append 方法前，让 StringBuffer 中包含的原有字符序列的长度为 n 。如果 k 小于 n，则新字符序列中索引 k 处的字符等于原有字符序列中索引 k 处的字符；否则它等于参数 sb 中索引 k-n 处的字符。该方法在 this（目标）对象上实现同步，但不在源（sb）上实现同步。参数：sb - 要追加的 StringBuffer 。返回：该对象的一个引用。从以下版本开始：1.4 appendpublic StringBuffer append(CharSequence s) 将指定的 CharSequence 追加到该序列。按顺序将 CharSequence 参数中的字符追加到该序列中，使该序列增加该参数的长度。该方法的结果与调用 this.append(s, 0, s.length()) 的结果完全相同；该方法在 this（目标）对象上实现同步，但不在源（s）上实现同步。如果s 为 null，则追加 4 个 "null" 字符。指定者：接口Appendable 中的 append参数：s - 要追加的 CharSequence 。返回：此对象的一个引用。从以下版本开始：1.5 appendpublic StringBuffer append(CharSequence s, int start, int end) 将指定 CharSequence 的子序列追加到此序列。按顺序追加参数 s 中的字符，即从索引 start 开始到索引 end 结束的此序列的内容。此序列增加的长度为 end - start 。假设此字符序列的长度在执行 append 方法前为 n 。如果 k 小于 n，则新字符序列中索引 k 处的字符等于原序列中索引 k 处的字符；否则它等于参数 s 中索引 k+start-n 处的字符。如果s 为 null ，则认为 s 参数包含 4 个字符 "null"，并以此为根据追加字符。指定者：接口Appendable 中的 append参数：s - 要追加的序列。start - 要追加的子序列的起始索引。end - 要追加的子序列的结束索引。返回：此对象的一个引用。抛出：IndexOutOfBoundsException 如果 start 或 end 为负；或者 start 大于 end；或者 end 大于 s.length() 从以下版本开始：1.5 appendpublic StringBuffer append(char[] str) 将char 数组参数的字符串表示形式追加到此序列。按顺序将数组参数中的字符追加到此序列的内容中。此字符将增加该参数的长度。该方法的总体效果与以下操作过程的效果相同：先使用 String.valueOf(char[]) 方法将参数转换为字符串，然后将所得字符串的字符追加到此字符序列。参数：str - 要追加的字符。返回：此对象的一个引用。appendpublic StringBuffer append(char[] str, int offset, int len) 将char 数组参数的子数组的字符串表示形式追加到此序列。将char 数组 str 中的字符按顺序追加到此序列的内容中，从索引 offset 开始。此字符的长度将增加 len 。该方法的最终效果与以下操作过程的效果相同：先使用 String.valueOf(char[]) 方法将参数转换为字符串，然后将所得字符串的字符追加到此字符序列。参数：str - 要追加的字符。offset - 要追加的第一个 char 的索引。len - 要追加的 char 的数量。返回：此对象的一个引用。appendpublic StringBuffer append(boolean b) 将boolean 参数的字符串表示形式追加到序列。参数将被转换成字符串，就好象使用了 String.valueOf 方法一样。然后，将所得字符串中的字符追加到此序列。参数：b - 一个 boolean 值。返回：此对象的一个引用。另请参见：String.valueOf(boolean), append(java.lang.String)appendpublic StringBuffer append(char c) 将char 参数的字符串表示形式追加到此序列。参数将被追加到此序列。此序列的长度将增加 1 。该方法的最终效果与以下操作过程的效果相同：先使用 String.valueOf(char[]) 方法将参数转换为字符串，然后将所得字符串的字符追加到此字符序列。指定者：接口Appendable 中的 append参数：c - 一个 char 值。返回：此对象的一个引用。appendpublic StringBuffer append(int i) 将int 参数的字符串表示形式追加到此序列。参数将被转换成字符串，就好象使用了 String.valueOf 方法一样。然后，将所得字符串中的字符追加到此序列。参数：i - 一个 int 值。返回：此对象的一个引用。另请参见：String.valueOf(int), append(java.lang.String)

Java的StringBuffer类中insert和append方法的区别insert能在字符串的任意位置添加，而append只能在末尾.
强烈建议这种问题去看JDK API文档，看看就一目了然了

java语言：String类的concat方法与StringBuffer类的append方法区别？内存状态？首先我们先看几个概念：1：在java内部是对+进行了重载，在处理String的过程中要创建一个StringBuffer对象，用StringBuffer对象的append方法对字符串进行连接，最后调用toString方法返回String字符串。2： +和concat操作，是先开辟一个要拼接的字符串的空间，在和老字符串一起拼接成一个新的字符串，所以在堆内存中是创建了三块空间的；然后先来说1和2的区别：line1: 用的是+，+在底层是通过StringBuffer对象的append方法对字符串进行连接，但是他也并不是直接添加的，我们看看他开辟了几块空间？“abc”“def”“ghi”,刚开始开辟了三块堆内存空间，执行一次+,“abcdef”这是第四块内存空间，最后是最终结果“abcdefghi”开辟了第五块堆内存空间，然后其余的被回收。line2:同样也是开辟了五块堆内存空间，concat()和+号的区别我们可以看下concat()源代码：public String concat(String str) {int otherLen = str.length();if (otherLen == 0) {return this;}int len = value.length;/*copyOf数组复制,copyOf()的第二个自变量指定要建立的新数组长度，如果新数组的长度超过原数组的长度，则保留为默认值null或0*/char buf[] = Arrays.copyOf(value, len + otherLen);//将字符从此字符串复制到目标字符数组,len为数组中的起始偏移量str.getChars(buf, len);return new String(buf, true);}我们可以看到concat()方法是通过copyOf(),和getChars();两个方法来拼接数组的。+在底层是通过StringBuffer对象的append方法对字符串进行连接。最后是StringBuffer：StringBuffer使用时，只会开辟一块内存空间，使用append添加或delete删除其内容时，也是在这一块内存空间中并不会生成多余的空间。所以速度是比较快的而String 每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，对速度的影响一定是相当大的。
请详细说一下java中append()的方法.【stringbuffer】本视频讲解的是Java面向对象编程语言中关于StringBuffer的知识，重点讲解了通过该对象可以去追加字符串，同时也提到了方法链的编程风格。
String和StringBuffer有什么区别？我在这里已经有过类型的解答了

然后你问的是从回收的角度上来讲的话,显然StringBuffer对内存的消耗要小的多,如果你用到了类似于我在上面那篇文章中举的例子:
String s="Hello Baidu";
s=new String("Hello Baidu");
s=s.concat("!");
在内存中会有两个空间是没有指向的,也不会被回收,因为它们都还不是Null.只有等到代码结束的时候才会被回收.
在我们小的程序中这样的开销还可以忽略,但是大型的工程中,大量的开销会对代码运行的速度带来很大的影响.

而StringBuffer因为它支持修改字符串的值,所以用它来作为应用是安全的

如果我的回答还是没有关系到你想问的地方,你可以给我留言,一起探讨 =)

如果对您有帮助，请记得采纳为满意答案，谢谢！祝您生活愉快！

vaela

string和stringbuffer类的区别（1）String类对象为不可变对象，一旦你修改了String对象的值，隐性重新创建了一个新的对象，释放原String对象，StringBuffer类对象为可修改对象，可以通过append()方法来修改值
（2）String类对象的性能远不如StringBuffer类。
关于以上具体解释如下：
在java中有3个类来负责字符的操作。
1.Character 是进行单个字符操作的，
2.String 对一串字符进行操作。不可变类。
3.StringBuffer 也是对一串字符进行操作，但是可变类。
String:
是对象不是原始类型.
为不可变对象,一旦被创建,就不能修改它的值.
对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.
String 是final类,即不能被继承.
StringBuffer:
是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象
它只能通过构造函数来建立,
StringBuffer sb = new StringBuffer();
注意:不能通过赋值符号对他进行赋值.
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 都会重新建立新的对象来保存新的值.
这样原来的对象就没用了,就要被垃圾回收.这也是要影响性能的.

Java中String ， StringBuilder和StringBuffer的区别区别
1、StringBuffer 与 StringBuilder 中的方法和功能完全是等价的，
2、只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，
而 StringBuilder 没有这个修饰，可以被认为是线程不安全的。
3、在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全
而StringBuffer则每次都需要判断锁，效率相对更低

java中StringBuffer类的常用方法怎么用？StringBuffer sb = new StringBuffer("Hello ");sb.append("world");//在sb尾部追加一个字符串, 此时变成 Hello world;sb.charAt(1) ;//返回下标为1的字符此处是 esb.insert(1,"d");//在 1 处插入新的字符串 d此时变为 Hedllo world;sb.reverse();//反转字符此时变成dlrow olldeHsb.delete(1,2);//删除字符串此时变为Hllo worldsb.replace(3,4,"new");//替换字符串从 3开始到4结束此时变为Hllnewworld全是手打的，望采纳
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 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转换成String

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

java数据的使用方法？boolean java基本数据类型，有两个值 true 和false；
1.直接赋值boolean b1=false;
2.由条件表达式赋值boolean b2=3>4;
3.由另一个boolean变量赋值boolean b3=b1;
4.由方法返回赋值boolean b4=list.ready();//假设ready方法返回一个boolean的话
程序中boolean为布尔类型变量

String类和StringBuffer类的区别String与StringBuffer的区别String:在String类中没有用来改变已有字符串中的某个字符的方法，由于不能改变一个java字符串中的某个单独字符，所以在JDK文档中称String类的对象是不可改变的。1）StringBuffer:StringBuffer类属于一种辅助类，可预先分配指定长度的内存块建立一个字符串缓冲区。这样使用StringBuffer类的append方法追加字符比 String使用 + 操作符添加字符到一个已经存在的字符串后面有效率得多。因为使用 + 操作符每一次将字符添加到一个字符串中去时，字符串对象都需要寻找一个新的内存空间来容纳更大的字符串，这无凝是一个非常消耗时间的操作。添加多个字符也就意味着要一次又一次的对字符串重新分配内存。使用StringBuffer类就避免了这个问题。2）StringBuffer是线程安全的，在多线程程序中也可以很方便的进行使用，但是程序的执行效率相对来说就要稍微慢一些。官方文档说明：
string和stringbuffer类的区别1.三者在执行速度方面的比较：StringBuilder > StringBuffer > String2.String <（StringBuffer，StringBuilder）的原因String：字符串常量StringBuffer：字符创变量StringBuilder：字符创变量从上面的名字可以看到，String是“字符创常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问，比如这段代码：1 String s = "abcd";2 s = s+1;3 System.out.print(s);// result : abcd1

String，StringBuffer和StringBuilder的区别StringBuffer属于线程安全，相对为重量级StringBuilder属于非线程安全，相对为轻量级线程安全的概念：网络编程中许多线程可能会同时运行一段代码。当每次运行结果和单独线程运行的结果是一样的，叫做线程安全。为了达到线程安全的目的在一定程度上会降低程序的性能。所以在单线程中，StringBuilder的性能要比StringBuffer高。多线程为了线程安全需要采用StingBuffer 。其实在线程不考虑的情况下，要是程序对性能的要求不高，太在意这两者的区别就没有什么意义（个人理解）。

java中String与StringBuffer的具体该怎么用？String可以这样用
String s = "I";
String o=s+"love"+"you";
StringBuffer可以这样用;
比如你在查询语句动态的给参数查询时可以用他拼凑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中。其实就是string类型的升级版其好处节省内存空间效率比string的单个拼接效率高
字符串的拼接：
String a="b";
a=a+"c";
System.out.println(a);//输出bc 这理念有a对象还有第二个又是一个对象两个对象
StringBuffer a1=new StringBuffer();
a1.append("b");
a1.append("c");
System.out.println(a1);//输出bc 一个对象 a1

java里面有了stringbuffer为什么还要有string如果字符串修改不频繁string在编写时还是很方便的,而且string是基础类型,不能随意删.
还有,下面两个类都不是string的子类.
stringbuilder适合单线程频繁修改字符串.
stringbuffer适合多线程修改字符串,因为这个方法在修改字符串时会检查线程锁,可以保证一个线程在修改字符串时,其他线程不能对同一个字符串进行修改.
上述内容,在java与c#中都一样.

有了stringbuffer ，为什么还要string他们的区别是很大的,它们是两个独立的类,可以这么说吧,除了名字有些相似,完全不相干.String类是不可改变的，如果你更改了String类的实例，那么以前的就“不存在了” ，所指向的是一个新的实例。而StringBuffer类是可以更改的。
看如下例子，体会这一点：
String s1="Hello";
String s2="Hello";
if(s1==s2)
System.out.println("Equal");
else
System.out.println("Not equla");
这个程序片断将输出Equal,原因是String类的实例是不能更改的.在生成第2个实例时它发现在缓冲池中已经有了"Hello"字符串,于是它就直接索引到这个字符串.
然而如果,你将第二行代码改为:
String s2 = new String("Hello");
再运行结果将是Not equal,因为更换了一个构造器形式,在生成第二个实例时,它就不在缓冲池中索引了,而是直接在内存中构造这样一个对象.因此,其句柄的值是不同的.
也就是说,当你更改了String类的实例,那么其句柄索引的将是在Heap Memory的另外一个位置的对象,以前的就不能再索引到了.
但是,StringBuffer类却不是如此,如果你更改了它的实例,但是在Heap Memory的缓冲池中,索引的是同一个实例.即更改了实例,但句柄的只是不变的,它是可以更改的!

连接字符串的时候为什么用StringBuffer而不用StringStringBuffer是可以改变的字符串，而String是不可改变的。每次使用System.String类中的方法之一时，都要在内存中创建一个新的字符串对象，就要为该对象分配新的空间。当要对字符串重复修改时，创建新的String对象相关的系统开销很大，就是要修改字符串而不创建新的对象，则用StringBuffer 。

StringBuffer明明比String好,为什么我们工作中还是用String？1.常量池里的string对象可以共享，stringbuffer必须每次在堆上new2.String的+操作，会自动被编译器优化为stringbuilder（jdk1.5开始，如果我没有记错）3.String的+操作比append更为直观

不是说StringBuffer类可以替代String类吗。。。怎么StringBuffer不能用toCharArray方法呢API 上有。

public void getChars(int srcBegin,
int srcEnd,
char[] dst,
int dstBegin)将字符从此序列复制到目标字符数组 dst 。要复制的第一个字符在索引 srcBegin 处；要复制的最后一个字符在索引 srcEnd-1 处。要复制的字符总数为 srcEnd-srcBegin 。要复制到 dst 子数组的字符从索引 dstBegin 处开始，结束于以下索引：

dstbegin + (srcEnd-srcBegin) - 1

参数：
srcBegin - 从此偏移量处开始复制。
srcEnd - 在此偏移量处停止复制。
dst - 用来保存复制数据的数组。
dstBegin - dst 中的偏移量。
抛出：
NullPointerException - 如果 dst 为 null 。
IndexOutOfBoundsException - 如果以下任意一项为 true：
srcBegin 为负
dstBegin 为负
srcBegin 参数大于 srcEnd 参数。
srcEnd 大于 this.length() 。
dstBegin+srcEnd-srcBegin 大于 dst.length
-------------------------------------------------------------------------------
先定义好数组：
StringBuffer sb = ......;
char[] c = new char[sb.length()];
sb.getChars(0, c.length, c, 0);