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

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

使用引號(hào)來(lái)創(chuàng)建字符串

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

所以看這個(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)鍵字，毫無(wú)疑問(wèn)會(huì)在堆中分配內(nèi)存，創(chuàng)建一個(gè)String類(lèi)的對(duì)象。因此，a這個(gè)在棧中的引用指向的是堆中的這個(gè)String對(duì)象的。

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

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

new構(gòu)造方法中傳入字符串常量, 會(huì)在堆中創(chuàng)建一個(gè)String對(duì)象, 但是這個(gè)對(duì)象不會(huì)再去新建字符數(shù)組(value) 來(lái)存儲(chǔ)內(nèi)容了, 會(huì)直接使用字符串常量對(duì)象中字符數(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;  //只是把傳入對(duì)象的value和引用傳給新的對(duì)象, 兩個(gè)對(duì)象其實(shí)是共用同一個(gè)數(shù)組
  this.hash = original.hash;
}

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

所以有下面的結(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來(lái)相加了
        System.out.println(s4 == s6);  //false  s4和s6 兩個(gè)都是使用了StringBulider來(lái)相加了
   	  	System.out.println(s6 == s66);     //false   兩個(gè)都是使用了StringBulider來(lái)相加了
  		  System.out.println(s5 == s7);    //false   s7是使用了StringBulider來(lái)相加了
        System.out.println(s5 == s8);  //false   s8是使用了StringBulider來(lái)相加了
        System.out.println(s7 == s8);  //false  兩個(gè)都是使用了StringBulider來(lái)相加了
        System.out.println(s9 == s8);  //false  兩個(gè)都是使用了StringBulider來(lái)相加了
    }

總結(jié)下就是：

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

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

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

String的intern()方法

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

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

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

來(lái)看看書(shū)本上給的例子：

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中，會(huì)得到兩個(gè)false，在JDK1.7中運(yùn)行，會(huì)得到一個(gè)true和一個(gè)false。

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

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

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

stringTable的小說(shuō)明

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

這里先再提一下字符串常量池，實(shí)際上，為了提高匹配速度，也就是為了更快地查找某個(gè)字符串是否在常量池中，Java在設(shè)計(jì)常量池的時(shí)候，還搞了張stringTable，這個(gè)有點(diǎn)像我們的hashTable，根據(jù)字符串的hashCode定位到對(duì)應(yīng)的桶，然后遍歷數(shù)組查找該字符串對(duì)應(yīng)的引用。如果找得到字符串，則返回引用，找不到則會(huì)把字符串常量放到常量池中，并把引用保存到stringTable了里面。

在JDK7、8中，可以通過(guò)-XX:StringTableSize參數(shù)StringTable大小

jdk1.6及其之前的intern()方法

在JDK6中，常量池在永久代分配內(nèi)存，永久代和Java堆的內(nèi)存是物理隔離的，執(zhí)行intern方法時(shí)，如果常量池不存在該字符串，虛擬機(jī)會(huì)在常量池中復(fù)制該字符串，并返回引用；如果已經(jīng)存在該字符串了，則直接返回這個(gè)常量池中的這個(gè)常量對(duì)象的引用。所以需要謹(jǐn)慎使用intern方法，避免常量池中字符串過(guò)多，導(dǎo)致性能變慢，甚至發(fā)生PermGen內(nèi)存溢出。

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

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

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

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

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

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

jdk1.7的intern()方法

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

區(qū)別在于

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

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

看個(gè)圖：

所以再看回我們書(shū)上的那個(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對(duì)象，然后調(diào)用intern，常量池中沒(méi)有“str01”這個(gè)常量對(duì)象，于是常量池中生成了一個(gè)對(duì)這個(gè)堆中string對(duì)象的引用。

然后給str1賦值的時(shí)候，因?yàn)槭菐б?hào)的，所以去常量池中找，發(fā)現(xiàn)有這個(gè)常量對(duì)象，就返回這個(gè)常量對(duì)象的引用，也就是str2引用所指向的堆中的String對(duì)象的地址。

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

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

總結(jié)

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

最新評(píng)論