JAVA字符串拼接操作規則說明

 

 

 

1.常量與常量的拼接結果在常量池，原理是編譯期優化

public void test1() {
        String s1 = "a" + "b" + "c";//等同於"abc"
        String s2 = "abc"; //"abc"-定是放在字符串常量池中，將此地址賦給s2
        /*
         *最終.java編譯成.class,再執行. class
         * string s1 = "abc";
         * string s2 = "abc
         */
        System.out.println(s1 == s2); //true
        System.out.println(s1.equals(s2)); //true

    }

 

 

2.常量池中不會存在相同內容的常量。

public void test2() {
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = " javaEEhadoop";
        String s4 = "javaEE" + "hadoop";//編澤期優化

        String s5 = s1 + "hadoop";
        String s6 = "javaEE"+ s2;
        String s7 = s1 + s2;
        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false
        //intern():判斷宇符串常量池中是否存在javaEEhadoop值，如果存在，則返回常量池中javaEEhadoop的地址:
        //如果字符串常量池中不存在javaEEhadoop，則在常量池中加載一份javaEEhadoop, 並返回此對象的地址。
        String s8 = s6.intern();
        System.out.println(s3 == s8);//true
    }

 

 

3.只要其中有一個是變量，結果就在堆中。變量拼接的原理是StringBuilder

public void test3() {
        String s1 = "a";
        String s2 = "b";
        String s3 = "ab";
        /*
        如下的s1 + s2的執行細節: (變量s是我臨時定義的)
        1、StringBuilder s = new stringBuilder();
        2、s. append("a")
        3、s.append("b")
        4、s.tostring() --> 約等於new string( "ab")
        補充:在jdk5. 0之后使用的是StringBuilder,在jdk5.0之前使用的是stringBuffer
        */
        String s4 = s1 + s2;//
        System.out.println(s3 == s4);//false
    }


    /*
    1.字符串拼接操作不一-定使用的是stringBuilder!
    如果拼接符號左右兩邊都是字符串常量或常量引用，則仍然使用編譯期優化，即非stringBuilder的方式。
    2.針對於final 修飾類、方法、基本數據類型、引用數據類型的量的結構時，能使用上final的時候建議使用上。
    */
    public void test4() {
        final String s1 = "a";
        final String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;
        System.out.println(s3 == s4);//true
    }

    public void test5() {
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false
        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true
    }

 

 

4.如果拼接的結果調用intern()方法，則主動將常量池中還沒有的字符串對象放入池中，並返回此對象地址。

 

拼接操作的效率對比：

通過StringBuilder 的append()的方式添加字符申的效率要遠高於使用String的字符串拼接方式!
詳情:1、StringBuilder的append()的方式:自始至終中只創建過-個StringBuilder的對象，使用String的字符串拼接方式:創建過多個StringBuilder和String的對象
　　 2、使用String的字符串拼接方式:內存中由於創建7鉸多的StringBuilder和String的對象， 內存占用更大:如果進行GC，需要花費額外的時間

改進的空間:在實際開發中，如果基本確定要前前后后添加的字符串長度不高於某個限定值highLevel的情況下,建議使用構造器
StringBuilder s = new StringBuilder(highLevel);//new char[highLevel ] 

 

intern()說明

String s = new String("1");
s. intern();//調用此方法之前，字符串常量池中已經存在了"1”
String s2 = "1";
System. out . println(s == s2);//jdk6: false  jdk7/8: false
String s3 = new String("1") + new String("1");//s3變量記錄的地址為: new String("11")
//執行完上一行代碼以后，字符串常量池中,是否存在"11"呢?答案:不存在! !
s3. intern();//在字符串常量池中生成"11”。如何理解: jdk6: 創建了一個新的對象"11", 也就有新的地址。
//jdk7:此時常量中並沒有創建"11",而是創建一個指向堆空間
String s4 = "11" ;//s4變量記錄的地址:使用的是上一行代碼執行時，在常量池中生成的"11”的地址
System. out . println(s3 == s4);//jdk6: false     jdk7/8: true 

 

 

new String("a") + new string("b")創建了幾個對象?

對象1: new stringBuilder()
對象2: new string("a")
對象3: 常量池中的"a”
對象4: new String("b")
對象5: 常量池中的"b”

深入剖析: StringBuilder的tostring():
對象6 : new string( "ab")
強調一下，tostring()的調用，在字符串常量池中，沒有生成"ab"