【Java基本功】一文讀懂String及其包裝類的實現原理

String做爲Java中最經常使用的引用類型，相對來講基本上都比較熟悉，不管在平時的編碼過程當中仍是在筆試面試中，String都很受到青睞，然而，在使用String過程當中，又有較多須要注意的細節之處。

String的鏈接

@Testpublic void contact () {    //1鏈接方式    String s1 = "a";    String s2 = "a";    String s3 = "a" + s2;    String s4 = "a" + "a";    String s5 = s1 + s2;    //表達式只有常量時，編譯期完成計算    //表達式有變量時，運行期才計算，因此地址不同    System.out.println(s3 == s4); //f    System.out.println(s3 == s5); //f    System.out.println(s4 == "aa"); //t
}複製代碼

String類型的intern

public void intern () {    //2：string的intern使用    //s1是基本類型，比較值。s2是string實例，比較實例地址    //字符串類型用equals方法比較時只會比較值    String s1 = "a";    String s2 = new String("a");    //調用intern時,若是s2中的字符不在常量池，則加入常量池並返回常量的引用    String s3 = s2.intern();    System.out.println(s1 == s2);    System.out.println(s1 == s3);}複製代碼

String類型的equals

//字符串的equals方法//    public boolean equals(Object anObject) {//            if (this == anObject) {//                return true;//            }//            if (anObject instanceof String) {//                String anotherString = (String)anObject;//                int n = value.length;//                if (n == anotherString.value.length) {//                    char v1[] = value;//                    char v2[] = anotherString.value;//                    int i = 0;//                    while (n-- != 0) {//                        if (v1[i] != v2[i])//                            return false;//                        i++;//                    }//                    return true;//                }//            }//            return false;//        }複製代碼

StringBuffer和Stringbuilder

底層是繼承父類的可變字符數組value

/** * The value is used for character storage. */char[] value;初始化容量爲16
/** * Constructs a string builder with no characters in it and an * initial capacity of 16 characters. */public StringBuilder() {    super(16);}這兩個類的append方法都是來自父類AbstractStringBuilder的方法
public AbstractStringBuilder append(String str) {    if (str == null)        return appendNull();    int len = str.length();    ensureCapacityInternal(count + len);    str.getChars(0, len, value, count);    count += len;    return this;}@Overridepublic StringBuilder append(String str) {    super.append(str);    return this;}
@Overridepublic synchronized StringBuffer append(String str) {    toStringCache = null;    super.append(str);    return this;}複製代碼

append

Stringbuffer在大部分涉及字符串修改的操做上加了synchronized關鍵字來保證線程安全，效率較低。
String類型在使用 + 運算符例如
String a = "a"
a = a + a;時，實際上先把a封裝成stringbuilder，調用append方法後再用tostring返回，因此當大量使用字符串加法時，會大量地生成stringbuilder實例，這是十分浪費的，這種時候應該用stringbuilder來代替string。複製代碼

擴容

#注意在append方法中調用到了一個函數
ensureCapacityInternal(count + len);該方法是計算append以後的空間是否足夠，不足的話須要進行擴容
public void ensureCapacity(int minimumCapacity) {    if (minimumCapacity > 0)        ensureCapacityInternal(minimumCapacity);}private void ensureCapacityInternal(int minimumCapacity) {    // overflow-conscious code    if (minimumCapacity - value.length > 0) {        value = Arrays.copyOf(value,                newCapacity(minimumCapacity));    }}若是新字符串長度大於value數組長度則進行擴容
擴容後的長度通常爲原來的兩倍 + 2；
假如擴容後的長度超過了jvm支持的最大數組長度MAX_ARRAY_SIZE。
考慮兩種狀況
若是新的字符串長度超過int最大值，則拋出異常，不然直接使用數組最大長度做爲新數組的長度。
private int hugeCapacity(int minCapacity) {    if (Integer.MAX_VALUE - minCapacity < 0) { // overflow        throw new OutOfMemoryError();    }    return (minCapacity > MAX_ARRAY_SIZE)        ? minCapacity : MAX_ARRAY_SIZE;}複製代碼

刪除

這兩個類型的刪除操做：
都是調用父類的delete方法進行刪除
public AbstractStringBuilder delete(int start, int end) {    if (start < 0)        throw new StringIndexOutOfBoundsException(start);    if (end > count)        end = count;    if (start > end)        throw new StringIndexOutOfBoundsException();    int len = end - start;    if (len > 0) {        System.arraycopy(value, start+len, value, start, count-end);        count -= len;    }    return this;}事實上是將剩餘的字符從新拷貝到字符數組value。複製代碼

這裏用到了system.arraycopy來拷貝數組，速度是比較快的

system.arraycopy方法

轉自知乎：
在主流高性能的JVM上（HotSpot VM系、IBM J9 VM系、JRockit系等等），能夠認爲System.arraycopy()在拷貝數組時是可靠高效的——若是發現不夠高效的狀況，請報告performance bug，確定很快就會獲得改進。
java.lang.System.arraycopy()方法在Java代碼裏聲明爲一個native方法。因此最naïve的實現方式就是經過JNI調用JVM裏的native代碼來實現。複製代碼

String的不可變性

關於String的不可變性，這裏轉一個不錯的回答

什麼是不可變？

String不可變很簡單，以下圖，給一個已有字符串"abcd"第二次賦值成"abcedl"，不是在原內存地址上修改數據，而是從新指向一個新對象，新地址。

String爲何不可變？

翻開JDK源碼，java.lang.String類起手前三行，是這樣寫的：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {     /** String本質是個char數組. 並且用final關鍵字修飾.*/     private final char value[];  ...  ... } 複製代碼

首先String類是用final關鍵字修飾，這說明String不可繼承。再看下面，String類的主力成員字段value是個char[]數組，並且是用final修飾的。

final修飾的字段建立之後就不可改變。 有的人覺得故事就這樣完了，其實沒有。由於雖然value是不可變，也只是value這個引用地址不可變。擋不住Array數組是可變的事實。

Array的數據結構看下圖。

也就是說Array變量只是stack上的一個引用，數組的本體結構在heap堆。

String類裏的value用final修飾，只是說stack裏的這個叫value的引用地址不可變。沒有說堆裏array自己數據不可變。看下面這個例子，

final int[] value={1,2,3} ；int[] another={4,5,6}; value=another;    //編譯器報錯，final不可變 value用final修飾，編譯器不容許我把value指向堆區另外一個地址。但若是我直接對數組元素動手，分分鐘搞定。
 final int[] value={1,2,3}; value[2]=100;  //這時候數組裏已是{1,2,100}   因此String是不可變，關鍵是由於SUN公司的工程師。 在後面全部String的方法裏很當心的沒有去動Array裏的元素，沒有暴露內部成員字段。
private final char value[]這一句裏，private的私有訪問權限的做用都比final大。並且設計師還很當心地把整個String設成final禁止繼承，避免被其餘人繼承後破壞。因此String是不可變的關鍵都在底層的實現，而不是一個final。考驗的是工程師構造數據類型，封裝數據的功力。 複製代碼

不可變有什麼好處？

這個最簡單地緣由，就是爲了安全。看下面這個場景（有評論反應例子不夠清楚，如今完整地寫出來），一個函數appendStr( )在不可變的String參數後面加上一段「bbb」後返回。appendSb( )負責在可變的StringBuilder後面加「bbb」。

總結如下String的不可變性。

1 首先final修飾的類只保證不能被繼承，而且該類的對象在堆內存中的地址不會被改變。

2 可是持有String對象的引用自己是能夠改變的，好比他能夠指向其餘的對象。

3 final修飾的char數組保證了char數組的引用不可變。可是能夠經過char[0] = 'a'來修改值。不過String內部並不提供方法來完成這一操做，因此String的不可變也是基於代碼封裝和訪問控制的。

舉個例子

final class Fi {    int a;    final int b = 0;    Integer s;
}final char[]a = {'a'};final int[]b = {1};@Testpublic void final修飾類() {    //引用沒有被final修飾，因此是可變的。    //final只修飾了Fi類型，即Fi實例化的對象在堆中內存地址是不可變的。    //雖然內存地址不可變，可是能夠對內部的數據作改變。    Fi f = new Fi();    f.a = 1;    System.out.println(f);    f.a = 2;    System.out.println(f);    //改變實例中的值並不改變內存地址。

    Fi ff = f;    //讓引用指向新的Fi對象，原來的f對象由新的引用ff持有。    //引用的指向改變也不會改變原來對象的地址    f = new Fi();    System.out.println(f);    System.out.println(ff);}這裏的對f.a的修改能夠理解爲char[0] = 'a'這樣的操做。只改變數據值，不改變內存值。複製代碼

要理解String裏的intern方法，就要注意基本數據類型的拆箱裝箱，以及對常量池的理解。

常量池和自動拆箱裝箱

自動拆箱和裝箱的原理其實與常量池有關。3.1存在棧中：public void(int a){int i = 1;int j = 1;}方法中的i 存在虛擬機棧的局部變量表裏，i是一個引用，j也是一個引用，它們都指向局部變量表裏的整型值 1.int a是傳值引用，因此a也會存在局部變量表。


3.2存在堆裏：class A{int i = 1;A a = new A();}i是類的成員變量。類實例化的對象存在堆中，因此成員變量也存在堆中，引用a存的是對象的地址，引用i存的是值，這個值1也會存在堆中。能夠理解爲引用i指向了這個值1。也能夠理解爲i就是1.

3.3包裝類對象怎麼存其實咱們說的常量池也能夠叫對象池。好比String a= new String("a").intern()時會先在常量池找是否有「a"對象若是有的話直接返回「a"對象在常量池的地址，即讓引用a指向常量」a"對象的內存地址。public native String intern();Integer也是同理。複製代碼

下圖是Integer類型在常量池中查找同值對象的方法。

public static Integer valueOf(int i) {    if (i >= IntegerCache.low && i <= IntegerCache.high)        return IntegerCache.cache[i + (-IntegerCache.low)];    return new Integer(i);}private static class IntegerCache {    static final int low = -128;    static final int high;    static final Integer cache[];
    static {        // high value may be configured by property        int h = 127;        String integerCacheHighPropValue =            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");        if (integerCacheHighPropValue != null) {            try {                int i = parseInt(integerCacheHighPropValue);                i = Math.max(i, 127);                // Maximum array size is Integer.MAX_VALUE                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);            } catch( NumberFormatException nfe) {                // If the property cannot be parsed into an int, ignore it.            }        }        high = h;
        cache = new Integer[(high - low) + 1];        int j = low;        for(int k = 0; k < cache.length; k++)            cache[k] = new Integer(j++);
        // range [-128, 127] must be interned (JLS7 5.1.7)        assert IntegerCache.high >= 127;    }
    private IntegerCache() {}}複製代碼

因此基本數據類型的包裝類型能夠在常量池查找對應值的對象，找不到就會自動在常量池建立該值的對象。

而String類型能夠經過intern來完成這個操做。

JDK1.7後，常量池被放入到堆空間中，這致使intern()函數的功能不一樣，具體怎麼個不一樣法，且看看下面代碼，這個例子是網上流傳較廣的一個例子，分析圖也是直接粘貼過來的，這裏我會用本身的理解去解釋這個例子：

[java] view plain copyString s = new String("1");  s.intern();  String s2 = "1";  System.out.println(s == s2);  
String s3 = new String("1") + new String("1");  s3.intern();  String s4 = "11";  System.out.println(s3 == s4);  輸出結果爲：
[java] view plain copyJDK1.6以及如下：false false  JDK1.7以及以上：false true複製代碼

JDK1.6查找到常量池存在相同值的對象時會直接返回該對象的地址。

JDK 1.7後，intern方法仍是會先去查詢常量池中是否有已經存在，若是存在，則返回常量池中的引用，這一點與以前沒有區別，區別在於，若是在常量池找不到對應的字符串，則不會再將字符串拷貝到常量池，而只是在常量池中生成一個對原字符串的引用。

那麼其餘字符串在常量池找值時就會返回另外一個堆中對象的地址。