String和StringBuffer区别

一：常量&变量：



String 被称为字符串常量，在创建后，它的值不能更改；

StringBuffer被称为字符串变量，它的值可以更改。



eg：

String str1="hello";

str1+=" world!";

PS：这个时候，系统其实创建了一个新的对象，把Str1的指向改成了“helloworld”，此时hello变成了系统垃圾。所以，如果一个字符串需要频繁地改动它的值，就要用StringBuffer来描述。



StringBuffer str1=new StringBuffer("[");

str1.append("hehe");

str1.append("]");

PS：在这一系列追加的过程中，是真正在改sb的值，不会产生多余的系统垃圾。





二：equals()和==：



equals()就是比较两字符串的Unicode序列是否相当，如果相等返回true;

==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。





三：常量池



常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

1：例一：

String str1 = "abcde";
       String str2 = "abc"+"de";
       System.out.println(str1 == str2);

此时的输出结果为：true

解释：首先，我们要知道Java会确保一个字符串常量只有一个拷贝。 

因为例子中的str1中的"abcde"是字符串常量，它们在编译期就被确定了。str2中的"abc"和"de"也都是字符串常量，他们连接起来，肯定也是一个字符串常量。所以str2在编译期就被解析为一个字符串常量，也就是常量池中"abcde"的一个引用。

PS：用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String()创建的字符串不放入常量池中，它们有自己的地址空间。只用在运行时才创建对象引用。





2：例二：

String str1 = "abcde";

       String str2 = new String("abcde");

       String str3 = "abc" + new String("de");

       System.out.println(str1 == str2);

       System.out.println(str1 == str3);

       System.out.println(str2 == str3);

此时的输出结果为：

false

false

false

解释：str1还是常量池中"abcde"的应用，str2无法在编译期确定，是运行时创建的新对象"abcde"的引用，str3因为有后半部分new String("de")所以也无法在编译期确定，所以也是一个新创建对象"abcde"的应用。

3：例三：
public static void main(String[] args) {
String str1 = "abcde";

    String str2 = "abc";
    String str3="de";
    String str4=str2+str3;
    System.out.println(str1 == str4);

}
}
输出结果为：false；
解释：此时的str1还是常量池中"abcde"的应用，str2是常量池总的"abc"的应用，str3是常量池总的"de"的应用



四：对象池

如果大家理解了前面的常量池，现在可以换个角度，引入对象池的概念，来解释前面的问题。

1：例一：

String str1 = new String("abc");

       String str2 = new String("abc");      

       System.out.println(str1 == str2);

此时的输出结果为：false

解释：str1(str2)是对象的引用，它位于栈中， new String() 才是对象，它位于堆中。

在执行语句的时候，jvm会马上在heap中创建一个String对象，然后将该对象的引用返回给用户。此时，他们在堆上是两个不同的对象，所以，他们的引用也不一样，这样就解释了为什么str1 != str2。但是"abc"的地址相同。



2：例二：

String str1 = new String("abc");

       String str2 = "abc";

       System.out.println(str1 == str2);

此时的输出结果为：false

解释：对于第二种初始化方法，jvm首先会在内部维护的strings pool中通过String的 equels 方法查找是对象池中是否存放有该String对象，如果有，则返回已有的String对象给用户，而不会在heap中重新创建一个新的String对象；如果对象池中没有该String对象，jvm则在heap中创建新的String对象，将其引用返回给用户，同时将该引用添加至strings pool中。



3：例三：

String str1 = "abc";

       String str2 = "abc";

       System.out.println(str1 == str2);

此时的输出结果为：true

解释：执行String str1 = "abc";时，jvm首先在strings pool中通过String的 equels 方法查找对象池中是否存放有该String对象，结果当然是没有该对象，所以jvm则在heap中创建新的String对象，将其引用返回给用户，同时将该引用添加至strings pool中。

执行String str2 = "abc";时，jvm继续查找对象池中是否存放有该String对象，查询结果是：“有”，所以把已有的String对象给用户，此时他们引用的是同一个对象，所以输出结果为str1 == str2





五：String.intern()

存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用。

注：String不会主动把常量注入到常量池中去！

1：例一：

String s0= "cengkis"; 

       String s1=new String("cengkis"); 

       String s2=new String("cengkis"); 

       System.out.println( s0==s1 ); 

       s1.intern();

       s2=s2.intern();

       System.out.println( s0==s1); 

       System.out.println( s0==s1.intern() ); 

       System.out.println( s0==s2 );

此时的输出结果为：

false

false   // 虽然执行了s1.intern(),但它的返回值没有赋给s1 

true 

true



2:例二：

String s1=new String("cengkis"); 

       String s2=s1.intern(); 

System.out.println( s1==s2 );

       System.out.println( s1==s1.intern() ); 

       System.out.println( s2==s1.intern() ); 

      

此时的输出结果为：

false

false

true

解释：此时，在常量池中，是没有"cengkis"的。当调用s1.intern()时，把"cengkis"注入到了常量池中。但是，他们属于两个不同的对象，所以，" s1==s2"会有" false"这个结果。同理，也就解释了下面两条语句的执行结果。