在本文描述它們的區別以前，先來了解一下JVM運行時數據區的內存模型。
《深刻JAVA虛擬機》書中是這樣描述的：JVM運行時數據區的內存模型由五部分組成： java
【1】方法區
【2】堆
【3】JAVA棧
【4】PC寄存器
【5】本地方法棧 app
對於String s = "haha" ,它的虛擬機指令：
0: ldc #16; //String haha
2: astore_1
3: return 編輯器
對於上面虛擬機指令，其各自的指令流程在《深刻JAVA虛擬機》這樣描述到(結合上面實例)： ide
ldc指令格式：ldc,index 工具
ldc指令過程： 優化
要執行ldc指令，JVM首先查找index所指定的常量池入口，在index指向的常量池入口，JVM將會查找CONSTANT_Integer_info，CONSTANT_Float_info和CONSTANT_String_info入口。若是尚未這些入口，JVM會解析它們。而對於上面的hahaJVM會找到CONSTANT_String_info入口，同時，將把指向被拘留String對象（由解析該入口的進程產生）的引用壓入操做數棧。 ui
astore_1指令格式：astore_1 spa
astore_1指令過程： 對象
要執行astore_1指令，JVM從操做數棧頂部彈出一個引用類型或者returnAddress類型值，而後將該值存入由索引1指定的局部變量中,即將引用類型或者returnAddress類型值存入局部變量1。 索引
return 指令的過程：
從方法中返回，返回值爲void。
談一下我我的理解：
從上面的ldc指令的執行過程能夠得出：s的值是來自被拘留String對象（由解析該入口的進程產生）的引用，便可以理解爲是從被拘留String對象的引用複製而來的，故我我的的理解是s的值是存在棧當中。上面是對於s值得分析，接着是對於"haha"值的分析,咱們知道，對於String s = "haha" 其中"haha"值在JAVA程序編譯期就肯定下來了的。簡單一點說，就是haha的值在程序編譯成class文件後，就在class文件中生成了（你們能夠用UE編輯器或其它文本編輯工具在打開class文件後的字節碼文件中看到這個haha值）。執行JAVA程序的過程當中，第一步是class文件生成，而後被JVM裝載到內存執行。那麼JVM裝載這個class到內存中，其中的haha這個值，在內存中是怎麼爲其開闢空間並存儲在哪一個區域中呢？
說到這裏，咱們不妨先來了解一下JVM常量池這個結構，《深刻JAVA虛擬機》書中有這樣的描述：
常量池
虛擬機必須爲每一個被裝載的類型維護一個常量池。常量池就是該類型所用到常量的一個有序集和，包括直接常量（string,integer和floating point常量）和對其餘類型，字段和方法的符號引用。對於String常量，它的值是在常量池中的。而JVM中的常量池在內存當中是以表的形式存在的，對於String類型，有一張固定長度的CONSTANT_String_info表用來存儲文字字符串值，注意：該表只存儲文字字符串值，不存儲符號引用。說到這裏，對常量池中的字符串值的存儲位置應該有一個比較明瞭的理解了。
在介紹完JVM常量池的概念後，接着談開始提到的"haha"的值的內存分佈的位置。對於haha的值，其實是在class文件被JVM裝載到內存當中並被引擎在解析ldc指令並執行ldc指令以前，JVM就已經爲haha這個字符串在常量池的CONSTANT_String_info表中分配了空間來存儲haha這個值。既然haha這個字符串常量存儲在常量池中，根據《深刻JAVA虛擬機》書中描述：常量池是屬於類型信息的一部分，類型信息也就是每個被轉載的類型，這個類型反映到JVM內存模型中是對應存在於JVM內存模型的方法區中，也就是這個類型信息中的常量池概念是存在於在方法區中，而方法區是在JVM內存模型中的堆中由JVM來分配的。因此，haha的值是應該是存在堆空間中的。
而對於String s = new String("haha") ,它的JVM指令：
0: new #16; //class String
3: dup
4: ldc #18; //String haha
6: invokespecial #20; //Method java/lang/String."":(Ljava/lang/String;)V
9: astore_1
10: return
對於上面虛擬機指令，其各自的指令流程在《深刻JAVA虛擬機》這樣描述到(結合上面實例)：
new指令格式：new indexbyte1,indexbyte2
new指令過程：
要執行new指令，Jvm經過計算(indextype1<<8)|indextype2生成一個指向常量池的無符號16位索引。而後JVM根據計算出的索引查找常量池入口。該索引所指向的常量池入口必須爲CONSTANT_Class_info。若是該入口尚不存在，那麼JVM將解析這個常量池入口，該入口類型必須是類。JVM從堆中爲新對象映像分配足夠大的空間，並將對象的實例變量設爲默認值。最後JVM將指向新對象的引用objectref壓入操做數棧。
dup指令格式：dup
dup指令過程：
要執行dup指令，JVM複製了操做數棧頂部一個字長的內容，而後再將複製內容壓入棧。本指令可以從操做數棧頂部複製任何單位字長的值。但絕對不要使用它來複制操做數棧頂部任何兩個字長(long型或double型)中的一個字長。上面例中，即複製引用objectref，這時在操做數棧存在2個引用。
ldc指令格式：ldc,index
ldc指令過程：
要執行ldc指令，JVM首先查找index所指定的常量池入口，在index指向的常量池入口，JVM將會查找CONSTANT_Integer_info，CONSTANT_Float_info和CONSTANT_String_info入口。若是尚未這些入口，JVM會解析它們。而對於上面的haha,JVM會找到CONSTANT_String_info入口，同時，將把指向被拘留String對象（由解析該入口的進程產生）的引用壓入操做數棧。
invokespecial指令格式：invokespecial,indextype1,indextype2
invokespecial指令過程：對於該類而言，該指令是用來進行實例初始化方法的調用。鑑於該指令篇幅，具體能夠查閱《深刻JAVA虛擬機》中描述。上面例子中，即經過其中一個引用調用String類的構造器，初始化對象實例，讓另外一個相同的引用指向這個被初始化的對象實例，而後前一個引用彈出操做數棧。
astore_1指令格式：astore_1
astore_1指令過程：
要執行astore_1指令，JVM從操做數棧頂部彈出一個引用類型或者returnAddress類型值，而後將該值存入由索引1指定的局部變量中,即將引用類型或者returnAddress類型值存入局部變量1。
return 指令的過程:
從方法中返回，返回值爲void。
要執行astore_1指令，JVM從操做數棧頂部彈出一個引用類型或者returnAddress類型值，而後將該值存入由索引1指定的局部變量中,即將引用類型或者returnAddress類型值存入局部變量1。
經過上面6個指令，能夠看出，String s = new String("haha");中的haha存儲在堆空間中，而s則是在操做數棧中。
上面是對s和haha值的內存狀況的分析和理解；那對於String s = new String("haha");語句,到底建立了幾個對象呢?
個人理解：這裏"haha"自己就是常量池中的一個對象，而在運行時執行new String()時，將常量池中的對象複製一份放到堆中，而且把堆中的這個對象的引用交給s持有。因此這條語句就建立了2個String對象。
下面是一些String相關的常見問題：
String中的final用法和理解
final StringBuffer a = new StringBuffer("111");
final StringBuffer b = new StringBuffer("222");
a=b;//此句編譯不經過
final StringBuffer a = new StringBuffer("111");
a.append("222");//編譯經過
可見，final只對引用的"值"(即內存地址)有效，它迫使引用只能指向初始指向的那個對象，改變它的指向會致使編譯期錯誤。至於它所指向的對象的變化，final是不負責的。
String 常量池問題的幾個例子
下面是幾個常見例子的比較分析和理解：
[1]
String a = "a1";
String b = "a" + 1;
System.out.println((a == b)); //result = true
String a = "atrue";
String b = "a" + "true";
System.out.println((a == b)); //result = true
String a = "a3.4";
String b = "a" + 3.4;
System.out.println((a == b)); //result = true
分析：JVM對於字符串常量的"+"號鏈接，將程序編譯期，JVM就將常量字符串的"+"鏈接優化爲鏈接後的值，拿"a" + 1來講，經編譯器優化後在class中就已是a1。在編譯期其字符串常量的值就肯定下來，故上面程序最終的結果都爲true。
[2]
String a = "ab";
String bb = "b";
String b = "a" + bb;
System.out.println((a == b)); //result = false
分析：JVM對於字符串引用，因爲在字符串的"+"鏈接中，有字符串引用存在，而引用的值在程序編譯期是沒法肯定的，即"a" + bb沒法被編譯器優化，只有在程序運行期來動態分配並將鏈接後的新地址賦給b。因此上面程序的結果也就爲false。
[3]
String a = "ab";
final String bb = "b";
String b = "a" + bb;
System.out.println((a == b)); //result = true
分析：和[3]中惟一不一樣的是bb字符串加了final修飾，對於final修飾的變量，它在編譯時被解析爲常量值的一個本地拷貝存儲到本身的常量池中或嵌入到它的字節碼流中。因此此時的"a" + bb和"a" + "b"效果是同樣的。故上面程序的結果爲true。
[4]
String a = "ab";
final String bb = getBB();
String b = "a" + bb;
System.out.println((a == b)); //result = false
private static String getBB() {
return "b";
}
分析：JVM對於字符串引用bb，它的值在編譯期沒法肯定，只有在程序運行期調用方法後，將方法的返回值和"a"來動態鏈接並分配地址爲b，故上面程序的結果爲false。
經過上面4個例子能夠得出得知：
String s = "a" + "b" + "c";
就等價於String s = "abc";
String a = "a";
String b = "b";
String c = "c";
String s = a + b + c;
這個就不同了，最終結果等於：
StringBuffer temp = new StringBuffer();
temp.append(a).append(b).append(c);
String s = temp.toString();
由上面的分析結果，可就不難推斷出String 採用鏈接運算符（+）效率低下緣由分析，形如這樣的代碼：
public class Test {
public static void main(String args[]) {
String s = null;
for(int i = 0; i < 100; i++) {
s += "a";
}
}
}
每作一次 + 就產生個StringBuilder對象，而後append後就扔掉。下次循環再到達時從新產生個StringBuilder對象，而後 append 字符串，如此循環直至結束。 若是咱們直接採用 StringBuilder 對象進行 append 的話，咱們能夠節省 N - 1 次建立和銷燬對象的時間。因此對於在循環中要進行字符串鏈接的應用，通常都是用StringBuffer或StringBulider對象來進行append操做。
String對象的intern方法理解和分析：
public class Test4 {
private static String a = "ab";
public static void main(String[] args){
String s1 = "a";
String s2 = "b";
String s = s1 + s2;
System.out.println(s == a);//false
System.out.println(s.intern() == a);//true
}
}
這裏用到Java裏面是一個常量池的問題。對於s1+s2操做，實際上是在堆裏面從新建立了一個新的對象,s保存的是這個新對象在堆空間的的內容，因此s與a的值是不相等的。而當調用s.intern()方法，卻能夠返回s在常量池中的地址值，由於a的值存儲在常量池中，故s.intern和a的值相等。