老感觉他们都差不多啊...string 用起来感觉也像是一个容器. 为什么还需要StringBuffer？

首先String不是容器

为什么还需要StringBuffer？
因为1.提高效率2.简化书写3.提高安全性

String是一种强不变类型,它的值一旦被赋予之后,在内存中的相应位置上的值就不会变化了.即便你用String的方法:concat(String str)和replace(char oldChar, char newChar)等等,所返回的值都是新创建的一个String类型,而不是在原内存地址上去更改,因此比如这样的一个赋值:
String s="Hello Baidu";
s=new String("Hello Baidu");

这样在内存中其实是开辟了两个内存空间来存放Hello Baidu,前面那个对象依然留在内存当中,而:
s=s.concat("!");
加上这样一句,s的值变为了Hello Baidu!,在内存中实际上是新创建了一个String对象装Hello Baidu!,而原有的Hello Baidu依然存在

StringBuffer就不同了,它是种可变类型,它的值被赋予之后,在运行期同样可以通过它的方法,如append(String str) 操作内存上的值,而不仅仅是它的引用而已,也就是说同样的对s的值进行修改
StringBuffer s="Hello Baidu";
s.append("!");
这样的操作其实只创建了一个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，它们可以储存和操作字符串，即包含多个字符的字符数据。String类表示内容不可改变的字符串。而StringBuffer类表示内容可以被修改的字符串。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。

接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。
StringBuffer sbf = new StringBuffer();  
for(int i=0;i<100;i++)
{
        sbf.append(i);
}
上面的代码效率很高，因为只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象。
String str = new String();  
for(int i=0;i<100;i++)
{
        str = str + i;
}
在讲两者区别时，应把循环的次数搞成10000，然后用endTime-beginTime来比较两者执行的时间差异，最后还要讲讲StringBuilder与StringBuffer的区别。

String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。

在java程序中，String（字符型）和StringBuffer（字节型，类似于字符缓冲区）是我们常用到的两个类型，String类型的变量不能被修改，而StringBuffer类型的变量可以被修改。
   举例：String a = "java "; a += "is good";，这里字符串a被改变了，是不是说明String类型字符可以被改变呢，其实，a是被改变了，但它所指向的地址也改变了，开始是指向"java "这个字符串地址，后来是指向"java is good"这个地址，所以String类型是不能被修改的。
   再看看StrignBuffer的情况，举例：StringBuffer a = new StringBuffer();
a.append("java "); a.append("is good");，这时a的值是"java is good"，a的值改变了，但它指向的地址还是没变，所以StringBuffer类型是可以被修改的。
   基于上面的原理，我们来看看它们在处理各自的字符串连接时是怎么做的。
   String在字符串连接时，在碰到每个"+"时，都用一个StringBuffer把两个字符串相加，然后再toString，在给它重新分配一个更大的空间。这样每一个"+"都要进行重新分配空间这样的操作，这无疑是很消耗资源的。
   StringBuffer在字符串连接时，直接把每一串字符加到自己的后面，同时引用的地址没有变，也就不会去进行地址重分配操作。
   相比之下，在字符串连接时，用StringBuffer效率要明显高于String。有一种情况比较特殊，如：
   String a = "java " + "is " + "good";
   StringBuffer s = new StringBuffer();
   s.append("java ").append("is ").append("good");
这时如果测试一下他们的时间，会发现String的效率要高于StringBuffer，这时因为连接的都字符串常量，在运行时，JVM会自动把String当作a = "java is good"，来处理，而对StringBuffer就会老老实实的进行连接处理，这种情况下String的效率是好于StringBuffer的。
   因为StringBuffer是对字符串直接进行添加操作，这就像数组一样，那么它一定有一个长度，StringBuffer的默认初始化长度是16，当字符串长度超过16时，它会自动增加长度，长度增加到（16*2）+2，也就是34，下一次当字符超过34时，长度会增加到（34*2）+2，就是70，当字符不断增多时，它就会按照这个规则去慢慢增加下去。现在要考虑的是，这个增加长度的操作也是耗资源的，我们要尽量的减少这种操作，那就需要我们在使用StringBuffer的时候，给它初始化一个长度；比如我要连接的字符串的长度是100，那么这时我给StringBuffer初始化100的长度是最合适的，它就不会去进行增加长度的操作了，当然你给它初始化160也是可以的。
   说到这里就要对JVM处理字符串的原理说一说，JVM会自动维护一个内存中滞留的字符串列表（唯一字符串池），用来避免对内存中出现重复的String对象，当JVM在执行程序时，如果程序要加载一个字符串，这时JVM会检查一下当前的字符串是否在滞留字符串列表里，如果在，就把当前的引用指向列表里的字符串地址，如果不再，就创建一个新的字符串对象。对于关键字new创建的字符串对象，JVM是不会做这种检查的，但可以用String.intern()方法来做强制检查。
   在JDK1.5以后，新增加了一个类型，StringBuilder，它的功能和StringBuffer一样，不同的是StringBuffer是线程安全的，而StringBuilder是线程不安全的，我们在处理字符串连接时，基本是不会用到线程安全的，显然StringBuilder的效率要好于StringBuffer，不过它们之间的差距是很小的，在sun的JDK里，是推荐用StringBuilder来代替StringBuffer的。

String是一种强不变类型,它的值一旦被赋予之后,在内存中的相应位置上的值就不会变化了.即便你用String的方法:concat(String str)和replace(char oldChar, char newChar)等等,所返回的值都是新创建的一个String类型,而不是在原内存地址上去更改,因此比如这样的一个赋值:
String s="Hello Baidu";
s=new String("Hello Baidu");

这样在内存中其实是开辟了两个内存空间来存放Hello Baidu,前面那个对象依然留在内存当中,而:
s=s.concat("!");
加上这样一句,s的值变为了Hello Baidu!,在内存中实际上是新创建了一个String对象装Hello Baidu!,而原有的Hello Baidu依然存在

StringBuffer就不同了,它是种可变类型,它的值被赋予之后,在运行期同样可以通过它的方法,如append(String str) 操作内存上的值,而不仅仅是它的引用而已,也就是说同样的对s的值进行修改
StringBuffer s="Hello Baidu";
s.append("!");
这样的操作其实只创建了一个StringBuffer的对象,大大节约了内存的开销

String是定长的，
StringBuffer是变长的

String是常量；它的值在创建之后不能改变。
StringBuffer支持可变的字符串。

在对Stirng做 += 或 + 操作时并不是把你要加的字符串加到了你的对象上,而是使用你要得到的(加好的)字符串重新创建了一个Stirng对象,并把引用重新指向给你
StringBuffer可以直接对对象进行追加字符串不用重新创建对象

所以你要重建的对象如果要经常改变内容使用StringBuffer会更好

现在都用Stringbuilder吧

简单来说:
String是对象而不是类型,它被初始化后是不可更改的:
StringBuffer它被初始化后还是可以更改的.

定长的原因 哈哈