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

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

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

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

所以看這個(gè)例子：

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

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

String a = new String("abc")；

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

然后，因?yàn)?quot;abc"是個(gè)常量，所以會去常量池中找，有沒有這個(gè)常量存在，沒的話分配一個(gè)空間，放這個(gè)"abc"常量，并將這個(gè)常量對象的空間地址給到堆中String對象里面；

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

new構(gòu)造方法中傳入字符串常量, 會在堆中創(chuàng)建一個(gè)String對象, 但是這個(gè)對象不會再去新建字符數(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和引用傳給新的對象, 兩個(gè)對象其實(shí)是共用同一個(gè)數(shù)組
  this.hash = original.hash;
}

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

所以有下面的結(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)于“+”運(yùn)算符

常量直接相加:

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

這里的true 是因?yàn)榫幾g期直接就把 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 兩個(gè)都是使用了StringBulider來相加了
   	  	System.out.println(s6 == s66);     //false   兩個(gè)都是使用了StringBulider來相加了
  		  System.out.println(s5 == s7);    //false   s7是使用了StringBulider來相加了
        System.out.println(s5 == s8);  //false   s8是使用了StringBulider來相加了
        System.out.println(s7 == s8);  //false  兩個(gè)都是使用了StringBulider來相加了
        System.out.println(s9 == s8);  //false  兩個(gè)都是使用了StringBulider來相加了
    }

總結(jié)下就是：

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

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

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

String的intern()方法

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

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

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

來看看書本上給的例子：

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

這段代碼在JDK1.6中，會得到兩個(gè)false，在JDK1.7中運(yùn)行，會得到一個(gè)true和一個(gè)false。

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

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

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

stringTable的小說明

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

這里先再提一下字符串常量池，實(shí)際上，為了提高匹配速度，也就是為了更快地查找某個(gè)字符串是否在常量池中，Java在設(shè)計(jì)常量池的時(shí)候，還搞了張stringTable，這個(gè)有點(diǎn)像我們的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方法時(shí)，如果常量池不存在該字符串，虛擬機(jī)會在常量池中復(fù)制該字符串，并返回引用；如果已經(jīng)存在該字符串了，則直接返回這個(gè)常量池中的這個(gè)常量對象的引用。所以需要謹(jǐn)慎使用intern方法，避免常量池中字符串過多，導(dǎo)致性能變慢，甚至發(fā)生PermGen內(nèi)存溢出。

看一個(gè)圖片來理解下：

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

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

看個(gè)詳細(xì)點(diǎn)的例子：

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

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

jdk1.7的intern()方法

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

區(qū)別在于

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

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

看個(gè)圖：

所以再看回我們書上的那個(gè)例子

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

再看一個(gè)例子

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

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

然后給str1賦值的時(shí)候，因?yàn)槭菐б柕模匀コＡ砍刂姓?，發(fā)現(xiàn)有這個(gè)常量對象，就返回這個(gè)常量對象的引用，也就是str2引用所指向的堆中的String對象的地址。

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

jdk7中雖然是把引用復(fù)制到常量池中, 但是不影響常量池的功能, 常量池就是減少常量的創(chuàng)建, 增加性能. 常量池中是引用還是能起到減少常量的作用, 因?yàn)橐米罱K還是會指向真實(shí)的對象.

總結(jié)

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