String深入了解

String是一個特殊的包裝類資料。可以用：

  String str = new String("abc");          
       String str = "abc";

兩種的形式來建立，第一種是用new()來建立對象的，它會在存放于堆中。每調用一次就會建立一個新的對象。而第二種是先在棧中建立一個對String類的對象引用變量str，然後通過符号引用去字元串常量池裡找有沒有"abc",如果沒有，則将"abc"存放進字元串常量池，并令str指向”abc”，如果已經有”abc” 則直接令str指向“abc”。

比較類裡面的數值是否相等時，用equals()方法；當測試兩個包裝類的引用是否指向同一個對象時，用==，下面用例子說明上面的理論。

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

可以看出str1和str2是指向同一個對象的。

  String str1 =new String ("abc");          
       String str2 =new String ("abc");          
       System.out.println(str1==str2); // false

用new的方式是生成不同的對象。每一次生成一個。

是以用第二種方式建立多個”abc”字元串,在記憶體中其實隻存在一個對象而已. 這種寫法有利與節省記憶體空間. 同時它可以在一定程度上提高程式的運作速度，因為JVM會自動根據棧中資料的實際情況來決定是否有必要建立新對象。而對于String str = new String("abc")；的代碼，則一概在堆中建立新對象，而不管其字元串值是否相等，是否有必要建立新對象，進而加重了程式的負擔。

另一方面, 要注意: 我們在使用諸如String str = "abc"；的格式定義類時，總是想當然地認為，建立了String類的對象str。擔心陷阱！對象可能并沒有被建立！而可能隻是指向一個先前已經建立的對象。隻有通過new()方法才能保證每次都建立一個新的對象。

由于String類的immutable性質，當String變量需要經常變換其值時，應該考慮使用StringBuffer類，以提高程式效率。

1. 首先String不屬于8種基本資料類型，String是一個對象。因為對象的預設值是null，是以String的預設值也是null；但它又是一種特殊的對象，有其它對象沒有的一些特性。

2. new String()和new String(”")都是申明一個新的空字元串，是空串不是null；

3. String str=”kvill”；String str=new String (”kvill”)的差別

示例：

  String s0="kvill";          
       String s1="kvill";          
       String s2="kv" + "ill";          
       System.out.println( s0==s1 );          
       System.out.println( s0==s2 );

結果為：

true

首先，我們要知結果為道Java 會確定一個字元串常量隻有一個拷貝。

因為例子中的 s0和s1中的”kvill”都是字元串常量，它們在編譯期就被确定了，是以s0==s1為true；而”kv”和”ill”也都是字元串常量，當一個字符串由多個字元串常量連接配接而成時，它自己肯定也是字元串常量，是以s2也同樣在編譯期就被解析為一個字元串常量，是以s2也是常量池中” kvill”的一個引用。是以我們得出s0==s1==s2；用new String() 建立的字元串不是常量，不能在編譯期就确定，是以new String() 建立的字元串不放入常量池中，它們有自己的位址空間。

示例：

  String s0="kvill";          
       String s1=new String("kvill");          
       String s2="kv" + new String("ill");          
       System.out.println( s0==s1 );          
       System.out.println( s0==s2 );          
       System.out.println( s1==s2 );

結果為：

false

例2中s0還是常量池中"kvill”的應用，s1因為無法在編譯期确定，是以是運作時建立的新對象”kvill”的引用，s2因為有後半部分 new String(”ill”)是以也無法在編譯期确定，是以也是一個新建立對象”kvill”的應用;明白了這些也就知道為何得出此結果了。

4. String.intern()：

再補充介紹一點：存在于.class檔案中的常量池，在運作期被JVM裝載，并且可以擴充。String的 intern()方法就是擴充常量池的一個方法；當一個String執行個體str調用intern()方法時，Java 查找常量池中是否有相同Unicode的字元串常量，如果有，則傳回其的引用，如果沒有，則在常量池中增加一個Unicode等于str的字元串并傳回它的引用；看示例就清楚了

示例：

  String s0= "kvill";          
       String s1=new String("kvill");          
       String s2=new String("kvill");          
       System.out.println( s0==s1 );          
       System.out.println( "**********" );          
       s1.intern();          
       s2=s2.intern(); //把常量池中"kvill"的引用賦給s2          
       System.out.println( s0==s1);          
       System.out.println( s0==s1.intern() );          
       System.out.println( s0==s2 );

結果為：

false

false //雖然執行了s1.intern(),但它的傳回值沒有賦給s1

true //說明s1.intern()傳回的是常量池中"kvill"的引用

true

最後我再破除一個錯誤的了解：有人說，“使用 String.intern() 方法則可以将一個 String 類的儲存到一個全局 String 表中，如果具有相同值的 Unicode 字元串已經在這個表中，那麼該方法傳回表中已有字元串的位址，如果在表中沒有相同值的字元串，則将自己的位址注冊到表中”如果我把他說的這個全局的 String 表了解為常量池的話，他的最後一句話，”如果在表中沒有相同值的字元串，則将自己的位址注冊到表中”是錯的：

示例：

  String s1=new String("kvill");          
       String s2=s1.intern();          
       System.out.println( s1==s1.intern() );          
       System.out.println( s1+" "+s2 );          
       System.out.println( s2==s1.intern() );

結果：

false

kvill kvill

true

在這個類中我們沒有聲名一個”kvill”常量，是以常量池中一開始是沒有”kvill”的，當我們調用s1.intern()後就在常量池中新添加了一個”kvill”常量，原來的不在常量池中的”kvill”仍然存在，也就不是“将自己的位址注冊到常量池中”了。

s1==s1.intern() 為false說明原來的”kvill”仍然存在；s2現在為常量池中”kvill”的位址，是以有s2==s1.intern()為true。

5. 關于equals()和==:

這個對于String簡單來說就是比較兩字元串的Unicode序列是否相當，如果相等傳回true;而==是比較兩字元串的位址是否相同，也就是是否是同一個字元串的引用。

6. 關于String是不可變的

這一說又要說很多，大家隻要知道String的執行個體一旦生成就不會再改變了，比如說：String str=”kv”+”ill”+” “+”ans”; 就是有4個字元串常量，首先”kv”和”ill”生成了”kvill”存在記憶體中，然後”kvill”又和” ” 生成 “kvill “存在記憶體中，最後又和生成了”kvill ans”;并把這個字元串的位址賦給了str,就是因為String的”不可變”産生了很多臨時變量，這也就是為什麼建議用StringBuffer的原因了，因為StringBuffer是可改變的。

下面是一些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常量池問題的幾個例子

下面是幾個常見例子的比較分析和了解：

  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。

  String a = "ab";          
       String bb = "b";          
       String b = "a" + bb;          
       System.out.println((a == b)); //result = false

分析：JVM對于字元串引用，由于在字元串的"+"連接配接中，有字元串引用存在，而引用的值在程式編譯期是無法确定的，即"a" + bb無法被編譯器優化，隻有在程式運作期來動态配置設定并将連接配接後的新位址賦給b。是以上面程式的結果也就為false。

  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。

  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的值相等。

總結

棧中用來存放一些原始資料類型的局部變量資料和對象的引用(String,數組.對象等等)但不存放對象内容

堆中存放使用new關鍵字建立的對象.

字元串是一個特殊包裝類,其引用是存放在棧裡的,而對象内容必須根據建立方式不同定(常量池和堆).有的是編譯期就已經建立好，存放在字元串常量池中，而有的是運作時才被建立.使用new關鍵字，存放在堆中。

String常量池問題的幾個例子

下面是幾個常見例子的比較分析和了解：

  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

  String a = "ab";          
       String bb = "b";          
       String b = "a" + bb;          
       System.out.println((a == b)); //result = false

  String a = "ab";          
       final String bb = "b";          
       String b = "a" + bb;          
       System.out.println((a == b)); //result = true

  String a = "ab";          
       final String bb = getBB();          
       String b = "a" + bb;          
       System.out.println((a == b)); //result = false          
       private static String getBB() {         
       return "b";          
       }

通過上面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";         
       }         
       }         
       }

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           
       }         
       }

總結

棧中用來存放一些原始資料類型的局部變量資料和對象的引用(String,數組.對象等等)但不存放對象内容

堆中存放使用new關鍵字建立的對象.

String深入了解

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

GridView終極用法(一)

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method