Java String：再學字符串

定義

Java 中字符串，用來定義一串字符。說白了就是一串 char 的數(shù)組。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0
    ...
}

實現(xiàn)三個接口：

  • Serializable：序列化。
  • Comparable：實現(xiàn) compareTo() 方法進行比較，A>B 返回大于正整數(shù)、A<B 返回負整數(shù)、相等返回 0。String 類比較的是字符串的字典值。
  • CharSequence：抽象 length()、subSequence()、charAt()。toString() 等方法。常用的實現(xiàn)此接口的類有 StringBuffer、StringBuilder。

字符串的拼接

"+"

Java 中使用 "+" 進行字符串的拼接，其實是編譯器對這種方式進行了處理。其原理還是通過轉(zhuǎn)換為 StringBuilder 或 StringBuffer，并通過其 append() 方法進行拼接。

String s = "a";
int i = 1;
String result = s+i;

編譯后

String s = "a";
int i = 1;
String result = new StringBuilder().append(s).append(i).toString();

另外，如果拼接的雙方為可知的字符串，編譯器會優(yōu)化處理。由于字符串的不可變性，編譯器會自動拼接。

System.out.println("a" + "b");

編譯后

System.out.println("ab");

"+" 的效率

由于編譯器隱式創(chuàng)建，如果在遍歷中大量使用拼接，會造成頻繁創(chuàng)建對象。

String s = "a";
for (int i = 0; i < 1000; i++) {
    s += "b";
}

編譯后

String s = "a";
for (int i = 0; i < 1000; i++) {
    s += new StringBuilder().append("b").toString();
}
System.out.print(s);

這個過程會創(chuàng)建 1000 個 StringBuilder 對象，無疑會造成內(nèi)存浪費。
優(yōu)化后的做法是創(chuàng)建一個 StringBuilder 對象進行拼接。

StringBuilder stringBuilder = new StringBuilder("a");
for (int i = 0; i < 1000; i++) {
    stringBuilder.append("b");
}
System.out.print(stringBuilder.toString());

內(nèi)存區(qū)域

在Java的內(nèi)存分配中，總共3種常量池，分別是Class常量池、運行時常量池、字符串常量池。

String 類型的數(shù)據(jù)就存放在 字符串常量池 中，是在 Class 文件經(jīng)過驗證和準備階段之后存入。在 HotSpot VM 環(huán)境字符串存放在常量池的 StringTable 中，是一個 Hash 表。

JDK 1.7 之后把字符串存放在了堆中，可能是為了方便在更大的內(nèi)存中分配和使用字符串。之前是存放在方法區(qū)的常量池中。

由于存放區(qū)域的改變，直接影響了 "==" 符號對比的結(jié)果?？聪旅娲a：

// JDK 1.8 環(huán)境
String s1 = "String";
String s2 = "String";
String s3 = new String("String");

System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false

在 JDK 1.8 的環(huán)境下，可以看到 s1 == s3 為 false，這是由 s1 和 s3 在堆內(nèi)存中指向的地址不一致造成的。
而在 JDK 1.6 的環(huán)境下， s1 == s3 可能為 true，因為它們都指向常量區(qū)相同字符串的地址。

intern方法

直接聲明的字符串會直接存放在常量池中，如果想在運行期向常量池存放字符串，可以使用 intern 方法。

這是一個 native 方法，調(diào)用后如果常量池存在該字符串則直接返回。如果不存在，在常量池創(chuàng)建并返回該字符串。

在批量創(chuàng)建字符串的時候，使用 intern 方法雖然比直接生成浪費點時間，但是會大大減少在堆內(nèi)存中創(chuàng)建字符串的數(shù)量，節(jié)省內(nèi)存空間。

==

對于字符串來說，equals 比較的是字符串的內(nèi)容。而 == 比較的是兩者的內(nèi)存地址。

// JDK 1.8 環(huán)境
String s0 = new String("1") + new String("x");
String s2 = s0.intern();
String s1 = "1x";
System.out.println(s2 == s0);//true
System.out.println(s2 == s1);//true
System.out.println(s0 == s1);//true
System.out.println("===");
String s3 = new String("1") + new String("x");
String s5 = s3.intern();
String s4 = "1x";
System.out.println(s5 == s3);//false s3 在堆內(nèi)存有自己指向的地址，s5 指向的是字符串 1x 的地址
System.out.println(s5 == s4);//true
System.out.println(s3 == s4);//flase 同理，不同地址不匹配
System.out.println(s5 == s0);//true
System.out.println(s4 == s0);//true
System.out.println("===");
System.out.println(s3 == s0);//false

為什么字符串不可變

從定義上說，String 是一個字符數(shù)組 final char[]，final 類型的不可變。

為什么會設(shè)計成不可變：為了 效率 和 安全。

  • 效率：既然是不可變的，那么在常量池中進行分配和搜索就會快很多。
  • 安全：兩種情況下的例子
    • 作為參數(shù)傳遞，如果一個字符串傳到了方法中，進行了拼接。由于不可變性，該字符串還是原來的信息。但是如果傳入了 StringBuilder 對象，進行 append，方法結(jié)束后該字符串的信息就發(fā)生了變化。
    • 引用指向的變化，可能會影響原信息。
public static void main(String[] args) {
    StringBuilder s1 = new StringBuilder("a");
    StringBuilder s2 = s1;
    s2.append("b");

    System.out.println(s1);//ab
    System.out.println(s2);//ab
 }

可以看到原來的 s1，被 s2 引用以后再拼接，原來的 s1 的數(shù)據(jù)也發(fā)生的變化。這是由于 s1 指向了一個字符串，s2 修改了引用的字符串，所以導致他們的數(shù)據(jù)都發(fā)生了變化。

StringBuilder、StringBuffer

在這里插入圖片描述

區(qū)別：

  • String 不可變，StringBuilder、StringBuffer 可變；主要是因為后兩者維護的是可變數(shù)組。
  • 速度：StringBuilder > StringBuffer > String ；StringBuilder 線程不安全，StringBuffer 加了 synchronized 所以會慢一些。最慢的 String 創(chuàng)建、修改和拼接都是需要新建的。
  • StringBuilder 線程不安全，StringBuffer 線程安全。

append 原理 JDK1.8

  1. StringBuilder 和 StringBuffer 使用 append() 方法時會調(diào)用父類的 append 方法。

AbstractStringBuilder # append

1. 父類 append 方法
public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    // 2. 確認是否需要擴容
    ensureCapacityInternal(count + len);
    // 3. 進行復制
    str.getChars(0, len, value, count);
    count += len;
    return this;
}
  1. ensureCapacityInternal 方法判斷如果緩存長度不夠，進行擴容并將原數(shù)據(jù)復制進擴容后的數(shù)組。

AbstractStringBuilder # ensureCapacityInternal

    private void ensureCapacityInternal(int minimumCapacity) {
        // 超出緩存容量
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }

AbstractStringBuilder # newCapacity

private int newCapacity(int minCapacity) {
    // 直接擴容為原數(shù)組長度兩倍+2
    int newCapacity = (value.length << 1) + 2;
    // 如果擴容后長度不夠，直接等于需要擴容的長度
    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
        ? hugeCapacity(minCapacity)
        : newCapacity;
}
  1. 最后調(diào)用拼接數(shù)據(jù)相應類的 getChars 方法進行數(shù)據(jù)拷貝，完成拼接。

String # getChars

public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
    if (srcBegin < 0) {
        throw new StringIndexOutOfBoundsException(srcBegin);
    }
    // 追加字符串長度 > 擴容后數(shù)組長度
    if (srcEnd > value.length) {
        throw new StringIndexOutOfBoundsException(srcEnd);
    }
    // 0 > 追加字符串長度
    if (srcBegin > srcEnd) {
        throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
    }
    // 將指定數(shù)組拷貝到新數(shù)組
    System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}

StringBuffer 方法與之類似，只不過加了 synchronized 關(guān)鍵字實現(xiàn)同步。

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

友情鏈接更多精彩內(nèi)容