摘要：與類基本相同，都是可變字符換字符串序列，不同點(diǎn)是是線程安全的，是線程不安全的。和區(qū)別在大部分情況下是線程安全的可變字符序列。在程序中可將字符串緩沖區(qū)安全地用于多線程。

  
轉(zhuǎn)載自飄過(guò)的小牛

我們先要記住三者的特征：

String 字符串常量

StringBuffer 字符串變量（線程安全）

StringBuilder 字符串變量（非線程安全）

查看 API 會(huì)發(fā)現(xiàn)，String、StringBuffer、StringBuilder 都實(shí)現(xiàn)了 CharSequence 接口，內(nèi)部都是用一個(gè)char數(shù)組實(shí)現(xiàn)，雖然它們都與字符串相關(guān)，但是其處理機(jī)制不同。

String：是不可改變的量，也就是創(chuàng)建后就不能在修改了。

StringBuffer：是一個(gè)可變字符串序列，它與 String 一樣，在內(nèi)存中保存的都是一個(gè)有序的字符串序列（char 類型的數(shù)組），不同點(diǎn)是 StringBuffer 對(duì)象的值都是可變的。

StringBuilder：與 StringBuffer 類基本相同，都是可變字符換字符串序列，不同點(diǎn)是 StringBuffer 是線程安全的，StringBuilder 是線程不安全的。

使用 String 類的場(chǎng)景：在字符串不經(jīng)常變化的場(chǎng)景中可以使用 String 類，例如常量的聲明、少量的變量運(yùn)算。

使用 StringBuffer 類的場(chǎng)景：在頻繁進(jìn)行字符串運(yùn)算（如拼接、替換、刪除等），并且運(yùn)行在多線程環(huán)境中，則可以考慮使用 StringBuffer，例如 XML 解析、HTTP 參數(shù)解析和封裝。

使用 StringBuilder 類的場(chǎng)景：在頻繁進(jìn)行字符串運(yùn)算（如拼接、替換、和刪除等），并且運(yùn)行在單線程的環(huán)境中，則可以考慮使用 StringBuilder，如 SQL 語(yǔ)句的拼裝、JSON 封裝等。

在性能方面，由于 String 類的操作是產(chǎn)生新的 String 對(duì)象，而 StringBuilder 和 StringBuffer 只是一個(gè)字符數(shù)組的擴(kuò)容而已，所以 String 類的操作要遠(yuǎn)慢于 StringBuffer 和 StringBuilder。

簡(jiǎn)要的說(shuō)， String 類型和 StringBuffer 類型的主要性能區(qū)別其實(shí)在于 String 是不可變的對(duì)象, 因此在每次對(duì) String 類型進(jìn)行改變的時(shí)候其實(shí)都等同于生成了一個(gè)新的 String 對(duì)象，然后將指針指向新的 String 對(duì)象。所以經(jīng)常改變內(nèi)容的字符串最好不要用 String ，因?yàn)?b>每次生成對(duì)象都會(huì)對(duì)系統(tǒng)性能產(chǎn)生影響，特別當(dāng)內(nèi)存中無(wú)引用對(duì)象多了以后， JVM 的 GC 就會(huì)開(kāi)始工作，那速度是一定會(huì)相當(dāng)慢的。

而如果是使用 StringBuffer 類則結(jié)果就不一樣了，每次結(jié)果都會(huì)對(duì) StringBuffer 對(duì)象本身進(jìn)行操作，而不是生成新的對(duì)象，再改變對(duì)象引用。所以在一般情況下我們推薦使用 StringBuffer ，特別是字符串對(duì)象經(jīng)常改變的情況下。

而在某些特別情況下， String 對(duì)象的字符串拼接其實(shí)是被 JVM 解釋成了 StringBuffer 對(duì)象的拼接，所以這些時(shí)候 String 對(duì)象的速度并不會(huì)比 StringBuffer 對(duì)象慢，而特別是以下的字符串對(duì)象生成中， String 效率是遠(yuǎn)要比 StringBuffer 快的：

String S1 = “This is only a" + “ simple" + “ test";

StringBuffer Sb = new StringBuilder(“This is only a").append(“ simple").append(“ test");

你會(huì)很驚訝的發(fā)現(xiàn)，生成 String S1 對(duì)象的速度簡(jiǎn)直太快了，而這個(gè)時(shí)候 StringBuffer 居然速度上根本一點(diǎn)都不占優(yōu)勢(shì)。其實(shí)這是 JVM 的一個(gè)把戲，在 JVM 眼里，這個(gè)

String S1 = “This is only a" + “ simple" + “test";

其實(shí)就是：

String S1 = “This is only a simple test";

所以當(dāng)然不需要太多的時(shí)間了。但大家這里要注意的是，如果你的字符串是來(lái)自另外的 String 對(duì)象的話，速度就沒(méi)那么快了，譬如：

1 String S2 = "This is only a";
2 String S3 = "simple";
3 String S4 = "test";
4 String S1 = S2 +S3 + S4;

這時(shí)候 JVM 會(huì)規(guī)規(guī)矩矩的按照原來(lái)的方式去做。

  
關(guān)于 equal 和 ==

  == 用于比較兩個(gè)對(duì)象的時(shí)候，是來(lái)check 是否兩個(gè)引用指向了同一塊內(nèi)存。

這個(gè)輸出就是false

這個(gè)輸出是true
一個(gè)特殊情況 ：

這是因?yàn)椋?br> 字符串緩沖池：程序在運(yùn)行的時(shí)候會(huì)創(chuàng)建一個(gè)字符串緩沖池。
當(dāng)使用 String s1 = "xyz"; 這樣的表達(dá)是創(chuàng)建字符串的時(shí)候（非new這種方式），程序首先會(huì)在這個(gè) String 緩沖池中尋找相同值的對(duì)象，
在 String str1 = "xyz"; 中，s1 先被放到了池中，所以在 s2 被創(chuàng)建的時(shí)候，程序找到了具有相同值的 str1
并將 s2 引用 s1 所引用的對(duì)象 "xyz"

 equals()

equals() 是object的方法，默認(rèn)情況下，它與== 一樣，比較的地址。
但是當(dāng)equal被重載之后，根據(jù)設(shè)計(jì)，equal 會(huì)比較對(duì)象的value。而這個(gè)是java希望有的功能。String 類就重寫(xiě)了這個(gè)方法

結(jié)果返回true

總的說(shuō)，String 有個(gè)特點(diǎn)： 如果程序中有多個(gè)String對(duì)象，都包含相同的字符串序列，那么這些String對(duì)象都映射到同一塊內(nèi)存區(qū)域，所以兩次new String("hello")生成的兩個(gè)實(shí)例，雖然是相互獨(dú)立的，但是對(duì)它們使用hashCode()應(yīng)該是同樣的結(jié)果。Note: 字符串?dāng)?shù)組并非這樣，只有String是這樣。即hashCode對(duì)于String，是基于其內(nèi)容的。

public class StringHashCode {
       public static void main(String[] args) {
            輸出結(jié)果相同
            String[] hellos = "Hello Hello".split(" " );
            System.out.println(""+hellos[0].hashCode());
            System.out.println(""+hellos[1].hashCode());
            輸出結(jié)果相同
            String a = new String("hello");
            String b = new String("hello");
            System.out.println(""+a.hashCode());
            System.out.println(""+b.hashCode());
      }
}

String 類是final類，不可以繼承。對(duì)String類型最好的重用方式是組合 而不是繼承。
String 有l(wèi)ength（）方法，數(shù)組有l(wèi)ength屬性

  
String s  = new String("xyz"); 創(chuàng)建了幾個(gè)字符串對(duì)象？

  兩個(gè)對(duì)象，一個(gè)靜態(tài)存儲(chǔ)區(qū)“xyz”, 一個(gè)用new創(chuàng)建在堆上的對(duì)象。

  
String 和 StringBuffer,String Builder區(qū)別？

在大部分情況下 StringBuffer > String

Java.lang.StringBuffer 是線程安全的可變字符序列。一個(gè)類似于 String 的字符串緩沖區(qū)，但不能修改。雖然在任意時(shí)間點(diǎn)上它都包含某種特定的字符序列，但通過(guò)某些方法調(diào)用可以改變?cè)撔蛄械拈L(zhǎng)度和內(nèi)容。在程序中可將字符串緩沖區(qū)安全地用于多線程。而且在必要時(shí)可以對(duì)這些方法進(jìn)行同步，因此任意特定實(shí)例上的所有操作就好像是以串行順序發(fā)生的，該順序與所涉及的每個(gè)線程進(jìn)行的方法調(diào)用順序一致。

StringBuffer 上的主要操作是 append 和 insert 方法，可重載這些方法，以接受任意類型的數(shù)據(jù)。每個(gè)方法都能有效地將給定的數(shù)據(jù)轉(zhuǎn)換成字符串，然后將該字符串的字符追加或插入到字符串緩沖區(qū)中。append 方法始終將這些字符添加到緩沖區(qū)的末端；而 insert 方法則在指定的點(diǎn)添加字符。

例如，如果 z 引用一個(gè)當(dāng)前內(nèi)容是 “start"的字符串緩沖區(qū)對(duì)象，則此方法調(diào)用 z.append("le") 會(huì)使字符串緩沖區(qū)包含 “startle"( 累加); 而 z.insert(4, "le") 將更改字符串緩沖區(qū)，使之包含 “starlet"。

在大部分情況下 StringBuilder > StringBuffer

java.lang.StringBuilder 一個(gè)可變的字符序列是 JAVA 5.0 新增的。此類提供一個(gè)與 StringBuffer 兼容的 API，但不保證同步，所以使用場(chǎng)景是單線程。該類被設(shè)計(jì)用作 StringBuffer 的一個(gè)簡(jiǎn)易替換，用在字符串緩沖區(qū)被單個(gè)線程使用的時(shí)候（這種情況很普遍）。如果可能，建議優(yōu)先采用該類，因?yàn)樵诖蠖鄶?shù)實(shí)現(xiàn)中，它比 StringBuffer 要快。兩者的使用方法基本相同。

String,StringBuffer,StringBuilder都實(shí)現(xiàn)了CharSequence接口。

javapublic interface CharSequence
{
    int length();
    // return the char value at the specified index
    char charAt(int index);
    // return a new CharSequence that is a subsequence
    // of this sequence.
    CharSequence subSequence(int start, int end);
    public String toString();
}

javapublic final class String{
    private final char value[]; // used for character storage
    private int the hash; // cache the hash code for the string
}

javapublic String()
public String(String original){
    this.value = original.value;
    this.hash = original.hash;
}
public String(char value[]){
    this.value = Arrays.copyOf(value, value.length);
}
public String(char value[], int offset, int count){
    // 判斷offset，count,offset+count是否越界之后
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

java    public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
        }
    }
   public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
    }

java    public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }

javapublic void getChars(int srcBegin, int srcEnd,
     char dst[], int dstBegin)
     {
     邊界檢測(cè)
     System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
     }

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

java    public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

java    public boolean regionMatches(int toffset, String other, int ooffset,
            int len)
   {
    //判斷邊界條件
            while (len-- > 0) {
            if (ta[to++] != pa[po++]) {
                return false;
            }
        }
            }
 public boolean regionMatches(boolean ignoreCase, int toffset,
            String other, int ooffset, int len) 
{    
    while (len-- > 0) {
            char c1 = ta[to++];
            char c2 = pa[po++];
            if (c1 == c2) {
                continue;
            }
            if (ignoreCase) {
                // If characters don"t match but case may be ignored,
                // try converting both characters to uppercase.
                // If the results match, then the comparison scan should
                // continue.
                char u1 = Character.toUpperCase(c1);
                char u2 = Character.toUpperCase(c2);
                if (u1 == u2) {
                    continue;
                }
                // Unfortunately, conversion to uppercase does not work properly
                // for the Georgian alphabet, which has strange rules about case
                // conversion.  So we need to make one last check before
                // exiting.
                if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
                    continue;
                }
            }
            return false;
        }
        return true;
}

java{
    return startsWith(suffix, value.length 
    - suffix.value.length);
    }

java return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);

java        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);

java public AbstractStringBuilder append(String str) {
        if (str == null) str = "null";
        int len = str.length();
        ensureCapacityInternal(count + len);//查看使用空間滿足，不滿足擴(kuò)展空間
        str.getChars(0, len, value, count);//getChars就是利用native的array copy,性能高效
        count += len;
        return this;
    }