string ，stringbuffer

String常量池详解：

　　1.String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不 可变的(immutable)。 String类有一个特殊的创建方法,就是使用""双引号来创建.例如new String("i am")实际创建了2个
　　String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同,
　　一个是编译期,一个是运行期 !java对String类型重载了+操作符,可以直接使用+对两个字符串进行连接。运行期调用String类的intern()方法可以向String Pool中动态添加对象。
　　
　　例1
　　String s1 = "sss111";
　　//此语句同上
　　String s2 = "sss111";
　　System.out.println(s1 == s2); //结果为true
　　例2
　　String s1 = new String("sss111");
　　String s2 = "sss111";
　　System.out.println(s1 == s2); //结果为false
　　例3
　　String s1 = new String("sss111");
　　s1 = s1.intern();
　　String s2 = "sss111";
　　System.out.println(s1 == s2);//结果为true
　　例4
　　String s1 = new String("111");
　　String s2 = "sss111";
　　String s3 = "sss" + "111";
　　String s4 = "sss" + s1;
　　System.out.println(s2 == s3); //true
　　System.out.println(s2 == s4); //false
　　System.out.println(s2 == s4.intern()); //true
　　

　　 结果上面分析,总结如下:

　 　 1.单独使用""引号创建的字符串都是常量,编译期就已经确定存储到String Pool中；

　　2，使用new String("")创建的对象会存储到heap中,是运行期新创建的；

　　3，使用只包含常量的字符串连接符如"aa" + "aa"创建的也是常量,编译期就能确定,已经确定存储到String Pool中；

　　4，使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在heap中；

还有几个经常考的面试题:
　　
　　String s1 = new String("s1") ;
　　String s2 = new String("s1") ;
　　上面创建了几个String对象?
　　答案:3个 ,编译期Constant Pool中创建1个,运行期heap中创建2个.（用new创建的每new一次就在堆上创建一个对象，用引号创建的如果在常量池中已有就直接指向，不用创建）；

2.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 ;      }