String、StringBuffer和StringBuilder的区别

String、StringBuffer、StringBuilder的区别

String 字符串常量

StringBuffer 字符串常量（线程安全）

StringBuilder 字符串常量（非线程安全）

String

1、String是对象不是基本数据类型

2、String是final类，不能够被继承。是不可变对象，一旦被创建，就不能够修改他的值

3、对于已经存在的String对象，修改他的值，就相当于重新创建一个String对象，然后赋值给它

StringBuffer

1、一个类似于String的字符串缓存区，对他的修改不会像String一样，给他重新创建对象

2、使用append（）就可以修改StringBuffer的值，使用toString（）可以转为字符串

StringBuilder

是JDK1.5以后，替代StringBuffer的一个类，很多时候都可以替代StringBuffer，和StringBuffer的区别在于，StringBuffer是线程安全的。但是在单线程的时候，StringBuilder的效率要比StringBuffer的效率高。

    简单直接的说，String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象。

每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不像String那样生成新的对象，再改变对象引用。所以在一般情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 效率是远要比 StringBuffer 快的：

String S1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder(“This is onlya”).append(“ simple”).append(“ test”)；

你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个

String S1 = “This is only a” + “ simple” + “test”;

其实就是：

String S1 = “This is only a simple test”;

所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：

String S2 = “This is only a”;

String S3 = “ simple”;

String S4 = “ test”;

String S1 = S2 +S3 + S4;

这时候 JVM 会规规矩矩的按照原来的方式去做。在大部分情况下 StringBuffer > String。

那么为什么StringBuilder的性能比StringBuffer的高呢？这则与线程安全有关。就是因为支持线程同步保证线程安全而导致性能下降的问题。StringBuffer和StringBuilder类的区别也在于此，JDK1.5之后引入的StringBuilder类不是线程安全的，但其在单线程中的性能要比StringBuffer高。

String str="You are nice."; 
str+="I love you so much.";

如果用StringBuffer类的话，代码如下：

StringBuffer str= new StringBuffer("You are nice.");
str.append("I love you so much.");

在用String类对象直接拼接时，JVM会创建一个临时的StringBuffer类对象，并调用其append()方法完成字符串的拼接，这是因为 String类是不可变的，拼接操作不得不使用StringBuffer类（并且－－JVM会将"You are nice."和"I love you so much."创建为两个新的String对象）。之后，再将这个临时StringBuffer对象转型为一个String，代价不菲！可见，在这一个简单 的一次拼接过程中，我们让程序创建了四个对象：两个待拼接的String，一个临时StringBuffer，和最后将StringBuffer转型成为 的String－－它当然不是最初的str了，这个引用的名称没变，但它指向了新的String对象。 而如果直接使用StringBuffer类，程序将只产生两个对象：最初的StringBuffer和拼接时的String（“I love you so much.”），也不再需要创建临时的StringBuffer类对象而后还得将其转换回String对象。

可以想象，当我们的字符串要被循环拼接若干段时，用String类直接操作会带来多少额外的系统开销，生成多少无用的临时StringBuffer对象，并处理多少次无谓的强制类型转换哪。

之后就是对于对象之间比较（equals和==）的关系了。使用equals，对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。

需要注意的是：String的intern()方法是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；

如下例子：

String string = new String("li");

String string1 = "li";

System.out.println(string == string1);

返回的是：

String string = new String("li").intern();

String string1 = "li";

System.out.println(string == string1);

返回的是：