String,StringBuilder和StringBuffer区别及使用场景

面试中常常会遇到这样的问题：1、你了解String类吗？2、String，StringBuilder和StringBuffer适合在什么样的场景下使用?

1、String类

首先看一下String的源码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public  final  class  String      implements  java.io.Serializable, Comparable<String>, CharSequence {      /** The value is used for character storage. */      private  final  char  value[];        /** The offset is the first index of the storage that is used. */      private  final  int  offset;        /** The count is the number of characters in the String. */      private  final  int  count;        /** Cache the hash code for the string */      private  int  hash;  // Default to 0        /** use serialVersionUID from JDK 1.0.2 for interoperability */      private  static  final  long  serialVersionUID = -6849794470754667710L;        ......   }

1）打开String源码们会发现这个类是final类，说明这个类不能被继承，其中的成员默认也是final修饰的。在之前的JVM实现版本中，被final修饰的方法会被转为内嵌调用以便提升效率。但是从JDK5/6之后，就抛弃了这种方式。因此现在不需要考虑通过final修饰来提高方法的调用效率。一般情况下，如果想要某个方法不被覆盖或者重载的情况下使用final修饰。

2）String采用immutable 设计模式，因此对象是最终的，不可被改变(在JDK的标准下是这样，当绕过JDK标准时，采用反射的方式就可以改变)。

• String s1 = "abcd";  
• String s2 = "abcd";  
• s1和s2是两个不同的对象

  Q：为什么将其设为不可变的，有什么好处？(了解)

  a.字符串常量池的需要

  字符串常量池(String pool, String intern pool, String保留池) 是Java堆内存中一个特殊的存储区域, 当创建一个String对象时,假如此字符串值已经存在于常量池中,则不会创建一个新的对象,而是引用已经存在的对象。
  

  如下面的代码所示,将会在堆内存中只创建一个实际String对象.

  1. String s1 = "abcd";  
  2. String s2 = "abcd";  
  假若字符串对象允许改变,那么将会导致各种逻辑错误,比如改变一个对象会影响到另一个独立对象. 严格来说，这种常量池的思想,是一种优化手段.
  

  b.允许String对象缓存HashCode
  Java中String对象的哈希码被频繁地使用, 比如在hashMap 等容器中。

  字符串不变性保证了hash码的唯一性,因此可以放心地进行缓存.这也是一种性能优化手段,意味着不必每次都去计算新的哈希码. 在String类的定义中有如下代码:

  1. private int hash;//用来缓存HashCode  
  c.安全性
  String被许多的Java类(库)用来当做参数,例如 网络连接地址URL,文件路径path,还有反射机制所需要的String参数等, 假若String不是固定不变的,将会引起各种安全隐患。

  假如有如下的代码:

  1. boolean connect(string s){  
  2.     if (!isSecure(s)) {   
  3. throw new SecurityException();   
  4. }  
  5.     // 如果在其他地方可以修改String,那么此处就会引起各种预料不到的问题/错误   
  6.     causeProblem(s);  
  7. }  

  3）上面列举出了String类中所有的成员属性，从上面可以看出String类其实是通过char数组来保存字符串的。

  　　下面再继续看String类的一些方法实现：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

  public  String substring( int  beginIndex,  int  endIndex) {      if  (beginIndex <  0 ) {          throw  new  StringIndexOutOfBoundsException(beginIndex);      }      if  (endIndex > count) {          throw  new  StringIndexOutOfBoundsException(endIndex);      }      if  (beginIndex > endIndex) {          throw  new  StringIndexOutOfBoundsException(endIndex - beginIndex);      }      return  ((beginIndex ==  0 ) && (endIndex == count)) ?  this  :          new  String(offset + beginIndex, endIndex - beginIndex, value);      }     public  String concat(String str) {      int  otherLen = str.length();      if  (otherLen ==  0 ) {          return  this ;      }      char  buf[] =  new  char [count + otherLen];      getChars( 0 , count, buf,  0 );      str.getChars( 0 , otherLen, buf, count);      return  new  String( 0 , count + otherLen, buf);      }     public  String replace( char  oldChar,  char  newChar) {      if  (oldChar != newChar) {          int  len = count;          int  i = - 1 ;          char [] val = value;  /* avoid getfield opcode */          int  off = offset;    /* avoid getfield opcode */            while  (++i < len) {          if  (val[off + i] == oldChar) {              break ;          }          }          if  (i < len) {          char  buf[] =  new  char [len];          for  ( int  j =  0  ; j < i ; j++) {              buf[j] = val[off+j];          }          while  (i < len) {              char  c = val[off + i];              buf[i] = (c == oldChar) ? newChar : c;              i++;          }          return  new  String( 0 , len, buf);          }      }      return  this ;

  　　从上面的三个方法可以看出，无论是sub操、concat还是replace操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。也就是说进行这些操作后，最原始的字符串并没有被改变。

  　　在这里要永远记住一点：

  　　“对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象”。

  　　在了解了于String类基础的知识后，下面来看一些在平常使用中容易忽略和混淆的地方。

  String str="hello world"和String str=new String("hello world")的区别

  想必大家对上面2个语句都不陌生，在平时写代码的过程中也经常遇到，那么它们到底有什么区别和联系呢？下面先看几个例子：

  1 2 3 4 5 6 7 8 9 10 11 12 13

  public  class  Main {                public  static  void  main(String[] args) {          String str1 =  "hello world" ;          String str2 =  new  String( "hello world" );          String str3 =  "hello world" ;          String str4 =  new  String( "hello world" );                    System.out.println(str1==str2);          System.out.println(str1==str3);          System.out.println(str2==str4);      } }

  输出的结果是：

  false

  true

  false

  为什么会出现这样的结果？下面解释一下原因：

  　　在前面一篇讲解关于JVM内存机制的一篇博文中提到 ，在class文件中有一部分 来存储编译期间生成的 字面常量以及符号引用，这部分叫做class文件常量池，在运行期间对应着方法区的运行时常量池。

  　　因此在上述代码中，String str1 = "hello world";和String str3 = "hello world"; 都在编译期间生成了 字面常量和符号引用，运行期间字面常量"hello world"被存储在运行时常量池（当然只保存了一份）。通过这种方式来将String对象跟引用绑定的话，JVM执行引擎会先在运行时常量池查找是否存在相同的字面常量，如果存在，则直接将引用指向已经存在的字面常量；否则在运行时常量池开辟一个空间来存储该字面常量，并将引用指向该字面常量。

  众所周知，通过new关键字来生成对象是在堆区进行的，而在堆区进行对象生成的过程是不会去检测该对象是否已经存在的。因此通过new来创建对象，创建出的一定是不同的对象，即使字符串的内容是相同的。

  String、StringBuffer以及StringBuilder的区别
  

  既然在Java中已经存在了String类，那为什么还需要StringBuilder和StringBuffer类呢？

  　　那么看下面这段代码：

  1 2 3 4 5 6 7 8 9

  public  class  Main {                public  static  void  main(String[] args) {          String string =  "" ;          for ( int  i= 0 ;i< 10000 ;i++){              string +=  "hello" ;          }      } }

  　　这句 string += "hello";的过程相当于将原有的string变量指向的对象内容取出与"hello"作字符串相加操作再存进另一个新的String对象当中，再让string变量指向新生成的对象。如果大家还有疑问可以反编译其字节码文件便清楚了

  
  

  从这段反编译出的字节码文件可以很清楚地看出：从第8行开始到第35行是整个循环的执行过程，并且每次循环会new出一个StringBuilder对象，然后进行append操作，最后通过toString方法返回String对象。也就是说这个循环执行完毕new出了10000个对象，试想一下，如果这些对象没有被回收，会造成多大的内存资源浪费。从上面还可以看出：string+="hello"的操作事实上会自动被JVM优化成：

  　　StringBuilder str = new StringBuilder(string);

  　　str.append("hello");

  　　str.toString();

  　　再看下面这段代码：

  1 2 3 4 5 6 7 8 9

  public  class  Main {                public  static  void  main(String[] args) {          StringBuilder stringBuilder =  new  StringBuilder();          for ( int  i= 0 ;i< 10000 ;i++){              stringBuilder.append( "hello" );          }      } }

  反编译字节码文件得到：
  

  
  

  从这里可以明显看出，这段代码的for循环式从13行开始到27行结束，并且new操作只进行了一次，也就是说只生成了一个对象，append操作是在原有对象的基础上进行的。因此在循环了10000次之后，这段代码所占的资源要比上面小得多。

  　　那么有人会问既然有了StringBuilder类，为什么还需要StringBuffer类？查看源代码便一目了然，事实上，StringBuilder和StringBuffer类拥有的成员属性以及成员方法基本相同，区别是StringBuffer类的成员方法前面多了一个关键字：synchronized，不用多说，这个关键字是在多线程访问时起到安全保护作用的,也就是说StringBuffer是线程安全的。

  　　下面摘了2段代码分别来自StringBuffer和StringBuilder，insert方法的具体实现：

  　　StringBuilder的insert方法

  1 2 3 4 5 6

  public  StringBuilder insert( int  index,  char  str[],  int  offset,                                int  len)    {        super .insert(index, str, offset, len);    return  this ;    }

  　　StringBuffer的insert方法：

  1 2 3 4 5 6

  public  synchronized  StringBuffer insert( int  index,  char  str[],  int  offset,                                              int  len)      {          super .insert(index, str, offset, len);          return  this ;      }

  不同场景下的三个类的性能测试

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

  public  class  Main {      private  static  int  time =  50000 ;      public  static  void  main(String[] args) {          testString();          testStringBuffer();          testStringBuilder();          test1String();          test2String();      }                  public  static  void  testString () {          String s= "" ;          long  begin = System.currentTimeMillis();          for ( int  i= 0 ; i<time; i++){              s +=  "java" ;          }          long  over = System.currentTimeMillis();          System.out.println( "操作" +s.getClass().getName()+ "类型使用的时间为：" +(over-begin)+ "毫秒" );      }            public  static  void  testStringBuffer () {          StringBuffer sb =  new  StringBuffer();          long  begin = System.currentTimeMillis();          for ( int  i= 0 ; i<time; i++){              sb.append( "java" );          }          long  over = System.currentTimeMillis();          System.out.println( "操作" +sb.getClass().getName()+ "类型使用的时间为：" +(over-begin)+ "毫秒" );      }            public  static  void  testStringBuilder () {          StringBuilder sb =  new  StringBuilder();          long  begin = System.currentTimeMillis();          for ( int  i= 0 ; i<time; i++){              sb.append( "java" );          }          long  over = System.currentTimeMillis();          System.out.println( "操作" +sb.getClass().getName()+ "类型使用的时间为：" +(over-begin)+ "毫秒" );      }            public  static  void  test1String () {          long  begin = System.currentTimeMillis();          for ( int  i= 0 ; i<time; i++){              String s =  "I" + "love" + "java" ;          }          long  over = System.currentTimeMillis();          System.out.println( "字符串直接相加操作：" +(over-begin)+ "毫秒" );      }            public  static  void  test2String () {          String s1 = "I" ;          String s2 =  "love" ;          String s3 =  "java" ;          long  begin = System.currentTimeMillis();          for ( int  i= 0 ; i<time; i++){              String s = s1+s2+s3;          }          long  over = System.currentTimeMillis();          System.out.println( "字符串间接相加操作：" +(over-begin)+ "毫秒" );      }       }

  
  

  测试结果（win7，Eclipse，JDK6)：
  

  
  

  上面提到string+="hello"的操作事实上会自动被JVM优化，看下面这段代码：
  

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  public  class  Main {      private  static  int  time =  50000 ;      public  static  void  main(String[] args) {          testString();          testOptimalString();      }                  public  static  void  testString () {          String s= "" ;          long  begin = System.currentTimeMillis();          for ( int  i= 0 ; i<time; i++){              s +=  "java" ;          }          long  over = System.currentTimeMillis();          System.out.println( "操作" +s.getClass().getName()+ "类型使用的时间为：" +(over-begin)+ "毫秒" );      }            public  static  void  testOptimalString () {          String s= "" ;          long  begin = System.currentTimeMillis();          for ( int  i= 0 ; i<time; i++){              StringBuilder sb =  new  StringBuilder(s);              sb.append( "java" );              s=sb.toString();          }          long  over = System.currentTimeMillis();          System.out.println( "模拟JVM优化操作的时间为：" +(over-begin)+ "毫秒" );      }       }

  　　执行结果：

  
  

  得到验证。

  　　下面对上面的执行结果进行一般性的解释：

  　　1）对于直接相加字符串，效率很高，因为在编译器便确定了它的值，也就是说形如"I"+"love"+"java"; 的字符串相加，在编译期间便被优化成了"Ilovejava"。这个可以用javap -c命令反编译生成的class文件进行验证。

  　　对于间接相加（即包含字符串引用），形如s1+s2+s3; 效率要比直接相加低，因为在编译器不会对引用变量进行优化。

  　　2）String、StringBuilder、StringBuffer三者的执行效率：

  　　StringBuilder > StringBuffer > String

  　　当然这个是相对的，不一定在所有情况下都是这样。

  　　比如String str = "hello"+ "world"的效率就比 StringBuilder st  = new StringBuilder().append("hello").append("world")要高。

  　　因此，这三个类是各有利弊，应当根据不同的情况来进行选择使用：

  　　当字符串相加操作或者改动较少的情况下，建议使用 String str="hello"这种形式；

  　　当字符串相加操作较多的情况下，建议使用StringBuilder，如果采用了多线程，则使用StringBuffer。

  说了这么多，这三个类在什么场景下使用呢？
  

  3、三个类是使用场景

  不需要频繁的拼接字符串的时候使用String，相反需要经常拼接字符串的时候使用StringBuilder。StringBuilder与StringBuffer相比，两个类似，不同的是StringBuilder是非线程安全的，适合在单线程的情况下使用。多线程情况也可以使用，不过需要手动加同步。StrngBuffer是线程安全的，适合在多线程的情况下使用。StringBuilder的效率要StringBuffer高