首先明白一個事，Java存在一個常量池，可以用來存儲字符串常量。
一、創建的字符串變量在內存中的區別
對於字符串：其對象的引用都是存儲在棧中的，如果是編譯期已經創建好（直接用雙引號定義的）的就存儲在常量池中，如果是運行期（new出來的）才能確定的就存儲在堆中。對於equals相等的字符串，在常量池中永遠只有一份，在堆中有多份。
例如：String str1="ABC"； 和String str2 = new String("ABC"); 兩者看似都是創建了一個字符串對象，但在內存中確是各有各的想法。
1、String str1="ABC" ：可能創建一個對象或者不創建對象。
如果"ABC"這個字符串在 Java String 池里不存在，會在 Java String 池創建一個String對象("ABC")。如果已經存在，str1直接reference to 這個String池里的對象。
在編譯期，JVM會去常量池來查找是否存在“ABC”，如果不存在，就在常量池中開辟一個空間來存儲“ABC”；如果存在，就不用新開辟空間。然后在棧內存中開辟一個名字為str1的空間，來存儲“ABC”在常量池中的地址值。
2、String str2 = new String("ABC") ：至少創建一個對象，也可能兩個。
因為用到 new 關鍵字，會在heap堆中創建一個 str2 的String 對象，它的value 是 "ABC"。同時，如果"ABC"這個字符串在 Java String 池里不存在，也會在 Java String 池創建一個String對象("ABC")。
在編譯階段JVM先去常量池中查找是否存在“ABC”，如果不存在，則在常量池中開辟一個空間存儲“ABC”。在運行時期，通過String類的構造器在堆內存中new了一個空間，然后將String池中的“ABC”復制一份存放到該堆空間中，在棧中開辟名字為str2的空間，存放堆中new出來的這個String對象的地址值。
也就是說，前者在初始化的時候可能創建了一個對象，也可能一個對象也沒有創建；后者因為new關鍵字，至少在內存中創建了一個對象，也有可能是兩個對象。
二、String類的特性
String類 是final修飾的，不可以被繼承。
String類的底層是基於char數組的。
三、intern() 方法
String 有一個intern() 方法，用來檢測在String pool是否已經有這個String存在。
public String intern() // 返回字符串對象的規范化表示形式
一個初始時為空的字符串池，它由類 String 私有地維護。
當調用 intern 方法時，如果常量池已經包含一個等於此 String 對象的字符串（該對象由 equals(Object) 方法確定），則返回池中的字符串。否則，將此 String 對象添加到池中，並且返回此 String 對象的引用。
它遵循對於任何兩個字符串 s 和 t，當且僅當 s.equals(t) 為 true 時，s.intern() == t.intern() 才為 true。
所有字面值字符串和字符串賦值常量表達式都是內部的。
返回：一個字符串，內容與此字符串相同，但它保證來自字符串池中。
// 考慮下面的問題：
String str1 = new String("ABC"); String str2 = new String("ABC"); // str1 == str2 的值是True 還是False呢？ False.
String str3 = "ABC"; String str4 = "ABC"; String str5 = "A" + "BC"; // str3 == str4 的值是True 還是False呢？ True. // str3 == str5 的值是True 還是False呢？ True. // 在寫代碼的時候，一般不要 String str2 = new String("ABC");
String a = "ABC"; String b = "AB"; String c = b+"C"; System.out.println(a==c); // false
a和b都是字符串常量所以在編譯期就被確定了！
而c中有個b是引用不是字符串常量，所以不會在編譯期確定。
而String是final的！所以在b+"c"的時候實際上是新創建了一個對象，然后在把新創建對象的引用傳給c。
public static void main(String[] args) throws Exception { String a = "b" ; String b = "b" ; System.out.println( a == b); String d = new String( "d" ).intern() ; String c = "d" ; //String d = new String( "d" ).intern() ;
System.out.println( c == d); System.out.println("------------------"); String d1 = new String( "d" ) ; String e1=d1.intern(); String c1 = "d" ; //String d = new String( "d" ).intern() ;
System.out.println( c1 == d1); System.out.println( c1 == e1); System.out.println( e1 == d1); System.out.println("------------------"); String s1=new String("kvill"); String s2=s1.intern(); System.out.println( s1==s2 ); //s1=s1.intern()
System.out.println( s1+" "+s2 ); System.out.println( s2==s1.intern() ); }
運行結果：
true
true
------------------
false
true
false
------------------
false kvill kvill true
s1==s1.intern()為false說明原來的“kvill”仍然存在；
String s1 = "china"; String s2 = "china"; String s3 = "china"; String ss1 = new String("china"); String ss2 = new String("china"); String ss3 = new String("china");
這里解釋一下，對於通過 new 產生一個字符串（假設為 ”china” ）時，會先去常量池中查找是否已經有了 ”china” 對象，如果沒有則在常量池中創建一個此字符串對象，然后堆中再創建一個常量池中此 ”china” 對象的拷貝對象。
也就是有道面試題： String s = new String(“xyz”); 產生幾個對象？
一個或兩個。如果常量池中原來沒有 ”xyz”, 就是兩個。如果原來的常量池中存在“xyz”時，就是一個。
對於基礎類型的變量和常量：變量和引用存儲在棧中，常量存儲在常量池中。
四、性能與安全
1、性能效率
String類被設計成不可變（immutable）類，所以它的所有對象都是不可變對象。例如：
String str = “hello";
str = str + "world“；
所以當上文str指向了一個String對象（內容為“hello”），然后對str進行“+”操作，str原來指向的對象並沒有變，而是str又指向了另外一個對象（“hello world”），原來的對象還在內存中。
由此也可以看出，頻繁的對String對象進行修改，會造成很大的內存開銷。此時應該用StringBuffer或StringBuilder來代替String。
而 new String() 更加不適合，因為每一次創建對象都會調用構造器在堆中產生新的對象，性能低下且內存更加浪費。
2、安全性
對象都是只讀的，所以多線程並發訪問也不會有任何問題。
由於不可變，用來存儲數據也是極為安全的。
五、博客推薦
這一篇寫的很詳細，推薦閱讀。
Java的string類常量池及不可變性：https://blog.csdn.net/u010887744/article/details/50844525
六、數組初始化時用new與不用new的區別
不同於String類，String由於實現了常量池，所以new 和不new 有區別：new的話，引用變量指向堆區。不new的話，引用變量指向常量池。
而對於數組的定義，初始化時用new與不用new 沒區別，只是兩種方式罷了，因為數組是引用數據類型，建立對象時，無論用不用new，數組實體都是放在堆內存中，引用變量放在棧內存。
參考文章：
https://blog.csdn.net/u014082714/article/details/50087563
https://blog.csdn.net/qq_33417486/article/details/82787598