Java基礎3：深刻理解String及包裝類

時間 2019-11-24

標籤 java 基礎深刻理解 string 包裝欄目 Java 简体版

原文原文鏈接

更多內容請關注微信公衆號【Java技術江湖】前端

這是一位阿里 Java 工程師的技術小站，做者黃小斜，專一 Java 相關技術：SSM、SpringBoot、MySQL、分佈式、中間件、集羣、Linux、網絡、多線程，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！（關注公衆號後回覆」資料「便可領取 3T 免費技術學習資源以及我我原創的程序員校招指南、Java學習指南等資源）java

**git

本節主要介紹字符串常量和字符串類型的區別程序員

具體代碼在個人GitHub中能夠找到github

https://github.com/h2pl/MyTech數組

文章首發於個人我的博客：安全

https://h2pl.github.io/2018/04/23/javase3微信

String的鏈接

@Test
public 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;
}
@Override
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

@Override
public 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};
@Test
public 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'這樣的操做。只改變數據值，不改變內存值。

有關常量池和intern的內容在上一節講到了。

具體參考：https://blog.csdn.net/a724888/article/details/80041698

下一節重講一下final關鍵字。

具體參考：https://blog.csdn.net/a724888/article/details/80045107