摘要：因此，這三個類是各有利弊，應當根據(jù)不同的情況來進行選擇使用當字符串相加操作或者改動較少的情況下，建議使用這種形式當字符串相加操作較多的情況下，建議使用，如果采用了多線程，則使用。

int a1= 1000;int a2=1000;if(a1==a2){System.out.println("yes");}

　　==的比較，基本數(shù)據(jù)類型看的是值是否相等，引用數(shù)據(jù)類型是看是否是一個對象（地址是否相等）

　　　　 Integer a=1377;

    Integer b=1377;
    if(a==b){
        System.out.println("yes");
    }

在裝箱的時候自動調(diào)用的是Integer的valueOf(int)方法。而在拆箱的時候自動調(diào)用的是Integer的intValue方法。

public static Integer valueOf(int i) {

if (i >= IntegerCache.low && i <= IntegerCache.high)
    return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);

}

由裝箱函數(shù)valueof可知，-128~127之間的整數(shù)有一個 IntegerCache緩存，不會創(chuàng)建新的對象。

面試題：

public class Main {

public static void main(String[] args) {

    Double i1 = 100.0;
    Double i2 = 100.0;
    Double i3 = 200.0;
    Double i4 = 200.0;

    System.out.println(i1==i2);
    System.out.println(i3==i4);
}

}

如果是int型的，100不會創(chuàng)建新對象，200會，但是浮點型的就不一樣了，看一下double的valueof源碼：

public static Double valueOf(String s) throws NumberFormatException {

    return new Double(parseDouble(s));
}

直接new了一個新對象了。（因為double的數(shù)表示范圍太大了，-128~127之間幾乎有無數(shù)的數(shù)字）

總結(jié)：

　　　　　Integer、Short、Byte、Character、Long這幾個類的valueOf方法的實現(xiàn)是類似的。

　　　　　Double、Float的valueOf方法的實現(xiàn)是類似的。

　　　　當 "=="運算符的兩個操作數(shù)都是 包裝器類型的引用，則是比較指向的是否是同一個對象，而如果其中有一個操作數(shù)是表達式（即包含算術(shù)運算）則比較的是數(shù)值（即會觸發(fā)自動拆箱的過程）。

public class Main {

public static void main(String[] args) {

    Integer a = 1;
    Integer b = 2;
    Integer c = 3;
    Integer d = 3;
    Integer e = 321;
    Integer f = 321;
    Long g = 3L;
    Long h = 2L;

    System.out.println(c==d); //在緩存的范圍內(nèi)，true
    System.out.println(e==f);//不在緩存的范圍內(nèi)，false
    System.out.println(c==(a+b));//a+b拆箱了，比較的是值，true
    System.out.println(c.equals(a+b));equals比較的是對象，所以拆箱后又裝箱了，但是在緩存之內(nèi)，還是同一個對象 true
    System.out.println(g==(a+b));true 比較的是值
    System.out.println(g.equals(a+b));比較的是對象，二者都不是同一個數(shù)據(jù)類型的自然new出來不是一個對象，false
    System.out.println(g.equals(a+h));二者都是long型的，也就是longvalueof方法，也是有-128~127的緩存機制的，true
}

}

（1）final char value[]; 由一個字符串數(shù)組構(gòu)成，final修飾，所以不可變。

（2）里面的一些字符串操作方法其實都是返回了一個新串：看一個源碼函數(shù)substring

public String substring(int beginIndex, int endIndex) {

    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);//new了一個新的string返回了
}

在這里要永遠記住一點：

“對String對象的任何改變都不影響到原對象，相關(guān)的任何change操作都會生成新的對象”。

　　　　 String s1="hello";

    String s2="hello";
    System.out.println(s1==s2);// true，hello是字符串常量，放在常量池里
    String s3=new String("hello");
    System.out.println(s1==s3);//false//new后是一個新的對象。

public StringBuilder append(String str) {

    super.append(str);
    return this;//在原有基礎(chǔ)上做變化的。
}

　　StringBuilder和StringBuffer類擁有的成員屬性以及成員方法基本相同，區(qū)別是StringBuffer類的成員方法前面多了一個關(guān)鍵字：synchronized，不用多說，這個關(guān)鍵字是在多線程訪問時起到安全保護作用的,也就是說StringBuffer是線程安全的。所以一般stringbuilder用的居多。

　　對于直接相加字符串，效率很高，因為在編譯器便確定了它的值，也就是說形如”I”+”love”+”java”; 的字符串相加，在編譯期間便被優(yōu)化成了”Ilovejava”。

　　對于間接相加（即包含字符串引用），形如s1+s2+s3; 效率要比直接相加低，因為在編譯器不會對引用變量進行優(yōu)化。

　　String、StringBuilder、StringBuffer三者的執(zhí)行效率：

StringBuilder > StringBuffer > String

當然這個是相對的，不一定在所有情況下都是這樣。

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

因此，這三個類是各有利弊，應當根據(jù)不同的情況來進行選擇使用：

當字符串相加操作或者改動較少的情況下，建議使用 String str=”hello”這種形式；

當字符串相加操作較多的情況下，建議使用StringBuilder，如果采用了多線程，則使用StringBuffer。

幾個面試題：

1. 下面這段代碼的輸出結(jié)果是什么？

String a = “hello2″; 　　String b = “hello” + 2; 　　System.out.println((a == b));

輸出結(jié)果為：true。原因很簡單，”hello”+2在編譯期間就已經(jīng)被優(yōu)化成”hello2″，因此在運行期間，變量a和變量b指向的是同一個對象。

2.下面這段代碼的輸出結(jié)果是什么？

String a = “hello2″; 　 String b = “hello”; String c = b + 2; System.out.println((a == c));

輸出結(jié)果為:false。由于有符號引用的存在，所以 String c = b + 2;不會在編譯期間被優(yōu)化，不會把b+2當做字面常量來處理的，因此這種方式生成的對象事實上是保存在堆上的。因此a和c指向的并不是同一個對象。

3.下面這段代碼的輸出結(jié)果是什么？

String a = “hello2″; 　 final String b = “hello”; String c = b + 2; System.out.println((a == c));

輸出結(jié)果為：true。對于被final修飾的變量，會在class文件常量池中保存一個副本，也就是說不會通過連接而進行訪問，對final變量的訪問在編譯期間都會直接被替代為真實的值。那么String c = b + 2;在編譯期間就會被優(yōu)化成：String c = “hello” + 2

4.下面這段代碼輸出結(jié)果為：

輸出結(jié)果為false。這里面雖然將b用final修飾了，但是由于其賦值是通過方法調(diào)用返回的，那么它的值只能在運行期間確定，因此a和c指向的不是同一個對象。

5.下面這段代碼的輸出結(jié)果是什么？

這里面涉及到的是String.intern方法的使用。在String類中，intern方法是一個本地方法，在JAVA SE6之前，intern方法會在運行時常量池中查找是否存在內(nèi)容相同的字符串，如果存在則返回指向該字符串的引用，如果不存在，則會將該字符串入池，并返回一個指向該字符串的引用。因此，a和d指向的是同一個對象，其余都是false

6.String str = new String(“abc”)創(chuàng)建了多少個對象？

這個問題在很多書籍上都有說到比如《Java程序員面試寶典》，包括很多國內(nèi)大公司筆試面試題都會遇到，大部分網(wǎng)上流傳的以及一些面試書籍上都說是2個對象，這種說法是片面的。

如果有不懂得地方可以參考這篇帖子：

http://rednaxelafx.iteye.com/...

首先必須弄清楚創(chuàng)建對象的含義，創(chuàng)建是什么時候創(chuàng)建的？這段代碼在運行期間會創(chuàng)建2個對象么？毫無疑問不可能。

很顯然，new只調(diào)用了一次，也就是說只創(chuàng)建了一個對象。

而這道題目讓人混淆的地方就是這里，這段代碼在運行期間確實只創(chuàng)建了一個對象，即在堆上創(chuàng)建了”abc”對象。而為什么大家都在說是2個對象呢，這里面要澄清一個概念 該段代碼執(zhí)行過程和類的加載過程是有區(qū)別的。在類加載的過程中，確實在運行時常量池中創(chuàng)建了一個”abc”對象，而在代碼執(zhí)行過程中確實只創(chuàng)建了一個String對象。

因此，這個問題如果換成 String str = new String(“abc”)涉及到幾個String對象？合理的解釋是2個。

個人覺得在面試的時候如果遇到這個問題，可以向面試官詢問清楚”是這段代碼執(zhí)行過程中創(chuàng)建了多少個對象還是涉及到多少個對象“再根據(jù)具體的來進行回答。

7.下面這段代碼1）和2）的區(qū)別是什么？

1）的效率比2）的效率要高，1）中的”love”+”java”在編譯期間會被優(yōu)化成”lovejava”，而2）中的不會被優(yōu)化。