String,StringBuffer,StringBuilder区别及性能详解

转载请申明出处：http://blog.csdn.net/qq_35372900/article/details/60751011
前言：
网上有不少写String,StringBuffer,StringBuilder的文章，但是总觉得写的不是很全面。所以今天带大家一起全面认识下它们。

共同点：
String 、StringBuffer、StringBuilder都是Java.lang包中对字符串进行操作的类，均实现了CharSequence接口。我们可以用其中任何一个类对字符串进行操作。并且他们都是final类型的类，不能被继承。

区别：

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 append(CharSequence s, int start, int end)
    {
        super.append(s, start, end);
        return this;
    }

　　而StringBuilder未对方法加同步锁，所以StringBuilder是非线程安全的。看如下源码同StringBuffer的区别。

public StringBuilder append(CharSequence s, int start, int end) {
        super.append(s, start, end);
        return this;
    }

大家都知道，线程安全情况下，效率肯定比非线程安全情况更低（java线程），所以在非多线程情况下，使用StringBuilder效率更好。

3、性能比较。（在繁复操作时）
　　String类由于Java中的共享设计，在修改变量值时使其反复改变栈中的对于堆的引用地址，所以性能低。
　　
　　StringBuffer和StringBuilder类设计时改变其值，其堆内存的地址不变，避免了反复修改栈引用的地址，其性能高。
　　
　　其中StringBuilder是专门类似于StringBuffer类的非线性安全类，即StringBuffer是线性安全的，适合于多线程操作；

　　StringBuilder是线性不安全的，适合于单线程操作，其性能比StringBuffer略高。看下代码

public class Performance {
public static void main(String[] args) {
    long begin1 = System.currentTimeMillis();
    String str = "";
     for(int i=0;i<10000;i++){
          str = str+i;
     }
     long end1 = System.currentTimeMillis();
     long time1 = end1 - begin1;
     System.out.println("1、String + time="+time1);

     long begin2 = System.currentTimeMillis();
     String str2 = "";
      for(int i=0;i<10000;i++){
           str2 = str2.concat(i+"");
      }
      long end2 = System.currentTimeMillis();
      long time2 = end2 - begin2;
      System.out.println("2、String concat time="+time2);

      long begin3 = System.currentTimeMillis();
      StringBuffer str3 = new StringBuffer();
       for(int i=0;i<10000;i++){
            str3.append(""+i);
       }
       long end3 = System.currentTimeMillis();
       long time3 = end3 - begin3;
       System.out.println("3、StringBuffer time="+time3);

       long begin4 = System.currentTimeMillis();
       StringBuilder str4 = new StringBuilder();
        for(int i=0;i<10000;i++){
             str4.append(""+i);
        }
        long end4 = System.currentTimeMillis();
        long time4 = end4 - begin4;
        System.out.println("4、StringBuilder time="+time4);
}
}

结果：

1、String + time=262
2、String concat time=103
3、StringBuffer time=5
4、StringBuilder time=3

最后：String 的共享设计

　　当String使用引号创建字符串时，会先去字符串池中找，找到了就返回，找不到就在字符串池中增加一个然后返回，这样由于共享提高了性能。

　　而new String()无论内容是否已经存在，都会开辟新的堆空间，栈中的堆内存也会改变。

　　下面是==来比较地址是否相等。
　　

public class String_Equals {
public static void main(String[] args) {
    String str1="合抱之木，生于毫末；九层之台，起于垒土；千里之行，始于足下。";
    String str11=str1;
    String str12="合抱之木，生于毫末；九层之台，起于垒土；千里之行，始于足下。";
    String str13=new String("合抱之木，生于毫末；九层之台，起于垒土；千里之行，始于足下。");

     System.out.println("String 的 str1 的hascode"+str1.hashCode());
     System.out.println("String 的 str11的hascode"+str11.hashCode());
     System.out.println("String 的 str12的hascode"+str12.hashCode());
     System.out.println("String 的 str13的hascode"+str13.hashCode());
     System.out.println("str1==str11  "+(str1==str11));
     System.out.println("str1==str12  "+(str1==str12));
     System.out.println("str1==str13  "+(str1==str13));
}
}

结果：

String 的 str1 的hascode895667206
String 的 str11的hascode895667206
String 的 str12的hascode895667206
String 的 str13的hascode895667206
str1==str11 true
str1==str12 true
str1==str13 false