**因為String是非常常用的類, jvm對其進行了優(yōu)化, jdk7之前jvm維護了很多的字符串常量在方法去的常量池中, jdk后常量池遷移到了堆中 **

方法區(qū)是一個運行時JVM管理的內(nèi)存區(qū)域，是一個線程共享的內(nèi)存區(qū)域，它用于存儲已被虛擬機加載的類信息、常量、靜態(tài)常量等。

使用引號來創(chuàng)建字符串

• 單獨（注意是單獨）使用引號來創(chuàng)建字符串的方式，字符串都是常量，在編譯期已經(jīng)確定存儲在常量池中了。
• 用引號創(chuàng)建一個字符串的時候，首先會去常量池中尋找有沒有相等的這個常量對象，沒有的話就在常量池中創(chuàng)建這個常量對象；有的話就直接返回這個常量對象的引用。

所以看這個例子：

String str1 = "hello";
String str2 = "hello";
System.out.println(str1 == str2);//true

###new的方式創(chuàng)建字符串

String a = new String("abc")；

new這個關(guān)鍵字，毫無疑問會在堆中分配內(nèi)存，創(chuàng)建一個String類的對象。因此，a這個在棧中的引用指向的是堆中的這個String對象的。

然后，因為"abc"是個常量，所以會去常量池中找，有沒有這個常量存在，沒的話分配一個空間，放這個"abc"常量，并將這個常量對象的空間地址給到堆中String對象里面；

如果常量池中已經(jīng)有了這個常量，就直接用那個常量池中的常量對象的引用唄，就只需要創(chuàng)建一個堆中的String對象。

new構(gòu)造方法中傳入字符串常量, 會在堆中創(chuàng)建一個String對象, 但是這個對象不會再去新建字符數(shù)組(value) 來存儲內(nèi)容了, 會直接使用字符串常量對象中字符數(shù)組(value)應(yīng)用,

具體方法參考

/**
* Initializes a newly created {@code String} object so that it represents
* the same sequence of characters as the argument; in other words, the
* newly created string is a copy of the argument string. Unless an
* explicit copy of {@code original} is needed, use of this constructor is
* unnecessary since Strings are immutable.
*
* @param  original
*         A {@code String}
*/
public String(String original) {
  this.value = original.value;  //只是把傳入對象的value和引用傳給新的對象, 兩個對象其實是共用同一個數(shù)組
  this.hash = original.hash;
}

value 雖然是private修飾的, 但是構(gòu)造方法中通過original.value;還是可以直接獲取另外一個對象的值. 因為這兩個對象是相同的類的對象

所以有下面的結(jié)果

public static void main(String[] args) {
      String s1 = new String("hello");
      String s2 = "hello";
      String s3 = new String("hello");
      System.out.println(s1 == s2);// false
      System.out.println(s1.equals(s2));// true
      System.out.println(s1 == s3);//false
  }

關(guān)于“+”運算符

常量直接相加:

String s1 = "hello" + "word";
String s2 = "helloword";
System.out,println(s1 == s2);//true

這里的true 是因為編譯期直接就把 s1 優(yōu)化成了 String s1 = “helloword”; 所以后面相等

非常量直接相加

 public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = new String("b");
        String s4 = s1 + s3;
        String s5="ab";
        String s6 = s1 + s2;
     		String s66= s1 + s2;
        String s7 = "a" + s2;
        String s8 = s1 + "b";
        String s9 = "a" + "b";
        System.out.println(s2 == s3);  //false   
        System.out.println(s4 == s5);   //false   s4 是使用了StringBulider來相加了
        System.out.println(s4 == s6);  //false  s4和s6 兩個都是使用了StringBulider來相加了
   	  	System.out.println(s6 == s66);     //false   兩個都是使用了StringBulider來相加了
  		  System.out.println(s5 == s7);    //false   s7是使用了StringBulider來相加了
        System.out.println(s5 == s8);  //false   s8是使用了StringBulider來相加了
        System.out.println(s7 == s8);  //false  兩個都是使用了StringBulider來相加了
        System.out.println(s9 == s8);  //false  兩個都是使用了StringBulider來相加了
    }

總結(jié)下就是：

兩個或者兩個以上的字符串常量直接相加，在預(yù)編譯的時候“+”會被優(yōu)化，相當(dāng)于把兩個或者兩個以上字符串常量自動合成一個字符串常量.

編譯期就會優(yōu)化, 編譯的字節(jié)碼直接就把加號去掉了, 直接定義一個常量

其他方式的字符串相加都會使用到 StringBuilder的.

String的intern()方法

這是一個native的方法，書上是這樣描述它的作用的：如果字符串常量池中已經(jīng)包含一個等于此String對象的字符串，則返回代表池中這個字符串的String對象；否則，將此String對象包含的字符添加到常量池中，并返回此String對象的引用。

并提到，在JDK1.6及其之前的版本，由于常量池分配在永久代內(nèi)，我們可以通過-XX:PermSize和-XX:MaxPermSize限制方法區(qū)的大小從而間接限制常量池的容量。

不僅如此，在intern方法返回的引用上，JDK1.6和JDK1.7也有個地方不一樣，

來看看書本上給的例子：

public static void main(String[] args) {
    String str1 = new StringBuilder("計算機").append("軟件").toString();
    System.out.println(str1.intern() == str1);
    String str2 = new StringBuilder("ja").append("va").toString();
    System.out.println(str2.intern() == str2);
}

這段代碼在JDK1.6中，會得到兩個false，在JDK1.7中運行，會得到一個true和一個false。

**書上說，產(chǎn)生差異的原因是：**在JDK1.6中，intern()方法會把首次遇到的字符串實例復(fù)制到永久代中，返回的也是永久代中這個字符串實例的引用，而由StringBuilder創(chuàng)建的字符串實例在Java堆上，所以必然不是同一個引用，將返回false。

而JDK1.7的intern()不會再復(fù)制實例，只是在常量池中記錄首次出現(xiàn)的實例的引用，因此intern()返回的引用和StringBuilder創(chuàng)建的那個字符串的實例是同一個。對str2比較返回false是因為"java"這個字符串在執(zhí)行StringBuilder.toString()之前就已經(jīng)出現(xiàn)過，字符串常量池中已經(jīng)有它的引用了，不符合“首次出現(xiàn)”的原則，而“計算機軟件”這個字符串則是首次出現(xiàn)的，因此返回true。

• jdk6和7 的差異是因為 7中常量池移動到堆中了, 并且對于常量池的處理也有差異, 6會把堆中的字符串復(fù)制一份副本到常量池中,
• 7 只是把堆中的字符串對象的引用放入常量池中, 所以第一個str1.intern()返回的也只是一個指向堆中對象的引用, 所以第一個出現(xiàn)false.
• 7的第二個false 是因為常量池中已經(jīng)有了"Java"對象了, 所以str2.intern()返回的是指向常量池中對象的引用, str2是指向堆中對象的引用, 所以false

stringTable的小說明

只是為了提高速度, 把常量池中的字符串常量維護了一個hashTable. 方便查找常量

這里先再提一下字符串常量池，實際上，為了提高匹配速度，也就是為了更快地查找某個字符串是否在常量池中，Java在設(shè)計常量池的時候，還搞了張stringTable，這個有點像我們的hashTable，根據(jù)字符串的hashCode定位到對應(yīng)的桶，然后遍歷數(shù)組查找該字符串對應(yīng)的引用。如果找得到字符串，則返回引用，找不到則會把字符串常量放到常量池中，并把引用保存到stringTable了里面。

在JDK7、8中，可以通過-XX:StringTableSize參數(shù)StringTable大小

jdk1.6及其之前的intern()方法

在JDK6中，常量池在永久代分配內(nèi)存，永久代和Java堆的內(nèi)存是物理隔離的，執(zhí)行intern方法時，如果常量池不存在該字符串，虛擬機會在常量池中復(fù)制該字符串，并返回引用；如果已經(jīng)存在該字符串了，則直接返回這個常量池中的這個常量對象的引用。所以需要謹(jǐn)慎使用intern方法，避免常量池中字符串過多，導(dǎo)致性能變慢，甚至發(fā)生PermGen內(nèi)存溢出。

看一個圖片來理解下：

當(dāng)然，這個常量池和堆是物理隔離的。

總之就是，要抓住“復(fù)制”這個字眼，常量池中存的是內(nèi)容為"abc"的常量對象。

看個詳細(xì)點的例子：

   public static void main(String[] args) {
        String a = new String("haha");
        System.out.println(a.intern() == a);//false
    }

首先，見到"haha"，產(chǎn)量池中沒有這個常量，所以會在常量池中放下這個常量對象，底層是通過ldc命令，"haha"被添加到字符串常量池，然后在stringTable中添加該常量的引用（引用好像是這個String對象中的char數(shù)組的地址），而a這個引用指向的是堆中這個String對象的地址，所以肯定是不同的。（而且一個在堆，一個在方法區(qū)中）。

jdk1.7的intern()方法

JDK 1.7后，intern方法還是會先去查詢常量池中是否有已經(jīng)存在，如果存在，則返回常量池中的引用，這一點與之前沒有區(qū)別，

區(qū)別在于

如果在常量池找不到對應(yīng)的字符串，則不會再將字符串拷貝到常量池，而只是在常量池中生成一個對原字符串的引用。簡單的說，就是往常量池放的東西變了：原來在常量池中找不到時，復(fù)制一個副本放到常量池，1.7后則是將在堆上的地址引用復(fù)制到常量池。

當(dāng)然這個時候，常量池被從方法區(qū)中移出來到了堆中。

看個圖：

所以再看回我們書上的那個例子

public static void main(String[] args) {
    String str1 = new StringBuilder("計算機").append("軟件").toString();
    System.out.println(str1.intern() == str1);
    String str2 = new StringBuilder("ja").append("va").toString();
    System.out.println(str2.intern() == str2);

再看一個例子

String str2 = new String("str")+new String("01");
str2.intern();
String str1 = "str01";
System.out.println(str2==str1);//true

這個返回true的原因也一樣，str2的時候，只有一個堆的String對象，然后調(diào)用intern，常量池中沒有“str01”這個常量對象，于是常量池中生成了一個對這個堆中string對象的引用。

然后給str1賦值的時候，因為是帶引號的，所以去常量池中找，發(fā)現(xiàn)有這個常量對象，就返回這個常量對象的引用，也就是str2引用所指向的堆中的String對象的地址。

所以str2和str1指向的是同一個東西，所以為true。

jdk7中雖然是把引用復(fù)制到常量池中, 但是不影響常量池的功能, 常量池就是減少常量的創(chuàng)建, 增加性能. 常量池中是引用還是能起到減少常量的作用, 因為引用最終還是會指向真實的對象.

總結(jié)

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。