String、StringBuffer与StringBuilder区别

1.String、StringBuffer与StringBuilder区别

(1）区别
* String内容不可变，StringBuffer和StringBuilder内容可变；
* StringBuilder非线程安全（单线程使用），String与StringBuffer线程安全（多线程使用）；
* 如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。


(2）String 字符串常量；

 * 字符串是不变的，他们的值在创造后不能改变。
 * 字符串缓冲区支持可变字符串，因为字符串对象是不可变的，所以它们可以共享。

查看String源码:

public final class String implements Serializable, Comparable<String>, CharSequence {
    private static final long serialVersionUID = -6849794470754667710L;
    private static final char REPLACEMENT_CHAR = (char) 0xfffd;
}

总结归纳了String的两个最重要的特点：

String是值不可变的常量，是线程安全的(can be shared)。
String类使用了final修饰符，String类是不可继承的。


(3）StringBuffer字符串变量（线程安全）是一个容器，最终会通过toString方法变成字符串；

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, Appendable, CharSequence
{
    /**
     * Constructs a string buffer with no characters in it and an
     * initial capacity of 16 characters.
     */
    public StringBuffer() {
        super(16);
    }
    public synchronized StringBuffer append(int i) {
        super.append(i);
        return this;
    }
    public synchronized StringBuffer delete(int start, int end) {
        super.delete(start, end);
        return this;
    }
}

（4）StringBuilder 字符串变量（非线程安全）与StringBuffer基本相同,未用synchronized修饰。

public final class StringBuilder extends AbstractStringBuilder
                       implements java.io.Serializable, Appendable, CharSequence {
   public StringBuilder() {
        super(16);
   }
   public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
    public StringBuilder delete(int start, int end) {
        super.delete(start, end);
        return this;
    }
}

2 String与StringBuffer区别

2.1 在修改时对象自身是否可变（主要区别）

（1） String在修改时不会改变对象自身
　　  在每次对 String类型 进行改变的时候其实都等同于生成了一个新的 String 对象，
     然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String 。
               String str = "abc";//地址str1
               str = "def";//地址str2

（2） StringBuffer在修改时会改变对象自身
　　  每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，
     再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别
     是字符串对象经常改变的情况下。StringBuffer 上的主要操作是 append 和 insert 方法。

         StringBuffer strBuffer = new StringBuffer("abc");//地址strBuffer,值是abc
         strBuffer.append("def");//地址strBuffer,值是abcdef

2.2 是否可变测试

public class MyTest {
    public static void main(String[] args) {
        String str = "abc";
        StringBuffer strBuffer = new StringBuffer();

        strBuffer.append("def");
        System.out.println( "@" + str.hashCode());
        System.out.println( "@" + strBuffer.hashCode());

        str = "aaa";
        strBuffer.append("bbb");
        System.out.println( "@" + str.hashCode());
        System.out.println( "@" + strBuffer.hashCode());
    }
}

　小结：String的地址已改变，对象已经改变为另一个；StringBuffer地址不变，还是同样的对象。

2.3 初始化区别

（1）String

       String s = null;
       String s = “abc”;

（2）StringBuffer

   StringBuffer s = null;
  //结果警告：Null pointer access: The variable result can only be null at this location

  StringBuffer s = new StringBuffer();
  //StringBuffer对象是一个空的对象

  StringBuffer s = new StringBuffer(“abc”);
  //创建带有内容的StringBuffer对象,对象的内容就是字符串”abc”

2.4 StringBuffer对象和String对象之间的互转

　　    StringBuffer和String属于不同的类型，也不能直接进行强制类型转换。
       StringBuffer对象和String对象之间的互转的代码如下：

                   String s = “abc”;
                   StringBuffer sb1 = new StringBuffer(“123”);
                   StringBuffer sb2 = new StringBuffer(s);   //String转换为StringBuffer
                   String s1 = sb1.toString();   //StringBuffer转换为String

2.5 StringBuffer相对String偏重

　　StringBuffer类中的方法主要偏重于对于字符串的变化，例如追加、插入和删除等，
   常用方法有：append方法、insert方法、deleteCharAt方法、reverse方法等。

2.6 总结

（1）如果要操作少量的数据  用String；
（2) (多线程下）经常需要对一个字符串进行修改，例如追加、插入和删除等操作，使用StringBuffer要更加适合一些。

3 StringBuffer与StringBuilder区别

3.1 StringBuilder是可变的对象，是5.0新增的

　　此类提供一个与StringBuffer兼容的 API，但不保证同步。
   该类被设计用作StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

3.2 线程安全性

（1） StringBuffer：线程安全的；
（2） StringBuilder：线程非安全的。

4 String,StringBuffer与StringBuilder速度区别

4.1 在大部分情况下，StringBuffer > String

　　由于String对象不可变，重复新建对象；
   StringBuffer对象可变。

4.2 StringBuilder > StringBuffer

　　当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，
   虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就
   是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的。

4.3 特殊情况， String > StringBuffer

//String效率是远要比StringBuffer快的：
String S1 = “This is only a” + “ simple” + “ test”;
StringBuffer Sb = new StringBuilder(“This is only a”).append(“simple”).append(“ test”);

//String速度是非常慢的：
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;


5. 运行速度，或者说是执行速度，在这方面运行速度快慢一般为：StringBuilder > StringBuffer > String

　1.String最慢的原因：

　　   String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，
   即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是
   可以更改的。以下面一段代码为例：

           String str="abc";
           System.out.println(str);
           str=str+"de";
           System.out.println(str);

　　   如果运行这段代码会发现先输出“abc”，然后又输出“abcde”，好像是str这个对象被更改了，其实，
   这只是一种假象罢了，JVM对于这几行代码是这样处理的，首先创建一个String对象str，并把“abc”
   赋值给str，然后在第三行中，其实JVM又创建了一个新的对象也名为str，然后再把原来的str的值
   和“de”加起来再赋值给新的str，而原来的str就会被JVM的垃圾回收机制（GC）给回收掉了，所以，
   str实际上并没有被更改，也就是前面说的String对象一旦创建之后就不可更改了。所以，
   Java中对String对象进行的操作实际上是一个不断创建新的对象并且将旧的对象回收的一个过程，
   所以执行速度很慢。

　　 而StringBuilder和StringBuffer的对象是变量，对变量进行操作就是直接对该对象进行更改，
    而不进行创建和回收的操作，所以速度要比String快很多。

　　另外，有时候我们会这样对字符串进行赋值

     String str="abc"+"de";
     StringBuilder stringBuilder=new StringBuilder().append("abc").append("de");
     System.out.println(str);
     System.out.println(stringBuilder.toString());

　　这样输出结果也是“abcde”和“abcde”，但是String的速度却比StringBuilder的反应速度要快很多，这是因为第1行中的操作和

　　String str="abcde";

　　是完全一样的，所以会很快，而如果写成下面这种形式

    String str1="abc";
    String str2="de";
    String str=str1+str2;
　 那么JVM就会像上面说的那样，不断的创建、回收对象来进行这个操作了。速度就会很慢。

　2. 再来说线程安全

　　在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

　　如果一个StringBuffer对象在字符串缓冲区被多个线程使用时，StringBuffer中
   很多方法可以带有synchronized关键字，所以可以保证线程是安全的，
   但StringBuilder的方法则没有该关键字，所以不能保证线程安全，有可能会出现
   一些错误的操作。所以如果要进行的操作是多线程的，那么就要使用StringBuffer，
   但是在单线程的情况下，还是建议使用速度比较快的StringBuilder。

　3. 总结一下
　　String：适用于少量的字符串操作的情况

　　StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

　　StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

       StringBuffer 的构造器会创建一个默认大小（通常是16）的字符数组。
   在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将
   原先的数组复制过来，再 丢弃旧的数组。在大多数情况下，你可以在创建
   StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。
   如：StringBuffer buffer = new StringBuffer(1000);