**因為String是非常常用的類, jvm對其進行了優化, jdk7之前jvm維護了很多的字符串常量在方法去的常量池中, jdk后常量池遷移到了堆中 **
方法區是一個運行時JVM管理的內存區域，是一個線程共享的內存區域，它用於存儲已被虛擬機加載的類信息、常量、靜態常量等。
###使用引號來創建字符串
- 單獨（注意是單獨）使用引號來創建字符串的方式，字符串都是常量，在編譯期已經確定存儲在常量池中了。
- 用引號創建一個字符串的時候，首先會去常量池中尋找有沒有相等的這個常量對象，沒有的話就在常量池中創建這個常量對象；有的話就直接返回這個常量對象的引用。
所以看這個例子：
String str1 = "hello";
String str2 = "hello";
System.out.println(str1 == str2);//true
###new的方式創建字符串
String a = new String("abc")；
new這個關鍵字，毫無疑問會在堆中分配內存，創建一個String類的對象。因此，a這個在棧中的引用指向的是堆中的這個String對象的。
然后，因為"abc"是個常量，所以會去常量池中找，有沒有這個常量存在，沒的話分配一個空間，放這個"abc"常量，並將這個常量對象的空間地址給到堆中String對象里面；如果常量池中已經有了這個常量，就直接用那個常量池中的常量對象的引用唄，就只需要創建一個堆中的String對象。
new構造方法中傳入字符串常量, 會在堆中創建一個String對象, 但是這個對象不會再去新建字符數組(value) 來存儲內容了, 會直接使用字符串常量對象中字符數組(value)應用,
具體方法參考
/** * 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和引用傳給新的對象, 兩個對象其實是共用同一個數組 this.hash = original.hash; }value 雖然是private修飾的, 但是構造方法中通過original.value;還是可以直接獲取另外一個對象的值. 因為這兩個對象是相同的類的對象
所以有下面的結果
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
}
###關於“+”運算符
常量直接相加:
String s1 = "hello" + "word";
String s2 = "helloword";
System.out,println(s1 == s2);//true
這里的true 是因為編譯期直接就把 s1 優化成了 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來相加了
}
總結下就是：
兩個或者兩個以上的字符串常量直接相加，在預編譯的時候“+”會被優化，相當於把兩個或者兩個以上字符串常量自動合成一個字符串常量.
編譯期就會優化, 編譯的字節碼直接就把加號去掉了, 直接定義一個常量
**其他方式的字符串相加都會使用到 StringBuilder的. **
###String的intern()方法.
這是一個native的方法，書上是這樣描述它的作用的：如果字符串常量池中已經包含一個等於此String對象的字符串，則返回代表池中這個字符串的String對象；否則，將此String對象包含的字符添加到常量池中，並返回此String對象的引用。
並提到，在JDK1.6及其之前的版本，由於常量池分配在永久代內，我們可以通過-XX:PermSize和-XX:MaxPermSize限制方法區的大小從而間接限制常量池的容量。
不僅如此，在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。
**書上說，產生差異的原因是：**在JDK1.6中，intern()方法會把首次遇到的字符串實例復制到永久代中，返回的也是永久代中這個字符串實例的引用，而由StringBuilder創建的字符串實例在Java堆上，所以必然不是同一個引用，將返回false。
而JDK1.7的intern()不會再復制實例，只是在常量池中記錄首次出現的實例的引用，因此intern()返回的引用和StringBuilder創建的那個字符串的實例是同一個。對str2比較返回false是因為"java"這個字符串在執行StringBuilder.toString()之前就已經出現過，字符串常量池中已經有它的引用了，不符合“首次出現”的原則，而“計算機軟件”這個字符串則是首次出現的，因此返回true。
jdk6和7 的差異是因為 7中常量池移動到堆中了, 並且對於常量池的處理也有差異, 6會把堆中的字符串復制一份副本到常量池中,
7 只是把堆中的字符串對象的引用放入常量池中, 所以第一個str1.intern()返回的也只是一個指向堆中對象的引用, 所以第一個出現false.
7的第二個false 是因為常量池中已經有了"Java"對象了, 所以str2.intern()返回的是指向常量池中對象的引用, str2是指向堆中對象的引用, 所以false
#####stringTable的小說明
只是為了提高速度, 把常量池中的字符串常量維護了一個hashTable. 方便查找常量
這里先再提一下字符串常量池，實際上，為了提高匹配速度，也就是為了更快地查找某個字符串是否在常量池中，Java在設計常量池的時候，還搞了張stringTable，這個有點像我們的hashTable，根據字符串的hashCode定位到對應的桶，然后遍歷數組查找該字符串對應的引用。如果找得到字符串，則返回引用，找不到則會把字符串常量放到常量池中，並把引用保存到stringTable了里面。
在JDK7、8中，可以通過-XX:StringTableSize參數StringTable大小
jdk1.6及其之前的intern()方法
在JDK6中，常量池在永久代分配內存，永久代和Java堆的內存是物理隔離的，執行intern方法時，如果常量池不存在該字符串，虛擬機會在常量池中復制該字符串，並返回引用；如果已經存在該字符串了，則直接返回這個常量池中的這個常量對象的引用。所以需要謹慎使用intern方法，避免常量池中字符串過多，導致性能變慢，甚至發生PermGen內存溢出。
看一個圖片來理解下：（圖片來自https://blog.csdn.net/soonfly/article/details/70147205）
當然，這個常量池和堆是物理隔離的。
總之就是，要抓住“復制”這個字眼，常量池中存的是內容為"abc"的常量對象。
看個詳細點的例子：
public static void main(String[] args) {
String a = new String("haha");
System.out.println(a.intern() == a);//false
}
首先，見到"haha"，產量池中沒有這個常量，所以會在常量池中放下這個常量對象，底層是通過ldc命令，"haha"被添加到字符串常量池，然后在stringTable中添加該常量的引用（引用好像是這個String對象中的char數組的地址），而a這個引用指向的是堆中這個String對象的地址，所以肯定是不同的。（而且一個在堆，一個在方法區中）。
jdk1.7的intern()方法
JDK 1.7后，intern方法還是會先去查詢常量池中是否有已經存在，如果存在，則返回常量池中的引用，這一點與之前沒有區別，區別在於，如果在常量池找不到對應的字符串，則不會再將字符串拷貝到常量池，而只是在常量池中生成一個對原字符串的引用。簡單的說，就是往常量池放的東西變了：原來在常量池中找不到時，復制一個副本放到常量池，1.7后則是將在堆上的地址引用復制到常量池。
當然這個時候，常量池被從方法區中移出來到了堆中。
看個圖：
（圖片來自https://blog.csdn.net/soonfly/article/details/70147205）
所以再看回我們書上的那個例子
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對象，然后調用intern，常量池中沒有“str01”這個常量對象，於是常量池中生成了一個對這個堆中string對象的引用。
然后給str1賦值的時候，因為是帶引號的，所以去常量池中找，發現有這個常量對象，就返回這個常量對象的引用，也就是str2引用所指向的堆中的String對象的地址。
所以str2和str1指向的是同一個東西，所以為true。
jdk7中雖然是把引用復制到常量池中, 但是不影響常量池的功能, 常量池就是減少常量的創建, 增加性能. 常量池中是引用還是能起到減少常量的作用, 因為引用最終還是會指向真實的對象.
#參考博客