轉載自飄過的小牛java
咱們先要記住三者的特徵:git
查看 API 會發現,String、StringBuffer、StringBuilder 都實現了 CharSequence 接口,內部都是用一個char數組實現,雖然它們都與字符串相關,可是其處理機制不一樣。github
使用 String 類的場景:在字符串不常常變化的場景中可使用 String 類,例如常量的聲明、少許的變量運算。數組
使用 StringBuffer 類的場景:在頻繁進行字符串運算(如拼接、替換、刪除等),而且運行在多線程環境中,則能夠考慮使用 StringBuffer,例如 XML 解析、HTTP 參數解析和封裝。安全
使用 StringBuilder 類的場景:在頻繁進行字符串運算(如拼接、替換、和刪除等),而且運行在單線程的環境中,則能夠考慮使用 StringBuilder,如 SQL 語句的拼裝、JSON 封裝等。多線程
在性能方面,因爲 String 類的操做是產生新的 String 對象,而 StringBuilder 和 StringBuffer 只是一個字符數組的擴容而已,因此 String 類的操做要遠慢於 StringBuffer 和 StringBuilder。app
簡要的說, String 類型和 StringBuffer 類型的主要性能區別其實在於 String 是不可變的對象, 所以在每次對 String 類型進行改變的時候其實都等同於生成了一個新的 String 對象
,而後將指針指向新的 String 對象
。因此常常改變內容的字符串最好不要用 String ,由於每次生成對象都會對系統性能產生影響
,特別當內存中無引用對象多了之後, JVM 的 GC 就會開始工做,那速度是必定會至關慢的
。函數
而若是是使用 StringBuffer 類則結果就不同了,每次結果都會對 StringBuffer 對象自己進行操做,而不是生成新的對象,再改變對象引用。因此在通常狀況下咱們推薦使用 StringBuffer ,特別是字符串對象常常改變的狀況下。工具
而在某些特別狀況下, String 對象的字符串拼接實際上是被 JVM 解釋成了 StringBuffer 對象的拼接,因此這些時候 String 對象的速度並不會比 StringBuffer 對象慢,而特別是如下的字符串對象生成中, String 效率是遠要比 StringBuffer 快的:性能
String S1 = 「This is only a" + 「 simple" + 「 test";
StringBuffer Sb = new StringBuilder(「This is only a").append(「 simple").append(「 test");
你會很驚訝的發現,生成 String S1 對象的速度簡直太快了,而這個時候 StringBuffer 竟然速度上根本一點都不佔優點。其實這是 JVM 的一個把戲,在 JVM 眼裏,這個
String S1 = 「This is only a" + 「 simple" + 「test";
其實就是:
String S1 = 「This is only a simple test";
因此固然不須要太多的時間了。但你們這裏要注意的是,若是你的字符串是來自另外的 String 對象的話,速度就沒那麼快了,譬如:
1 String S2 = "This is only a"; 2 String S3 = "simple"; 3 String S4 = "test"; 4 String S1 = S2 +S3 + S4;
這時候 JVM 會規規矩矩的按照原來的方式去作。
關於 equal 和 ==
== 用於比較兩個對象的時候,是來check 是否兩個引用指向了同一塊內存。
這個輸出就是false
這個輸出是true
一個特殊狀況 :
這是由於:
字符串緩衝池:程序在運行的時候會建立一個字符串緩衝池。
當使用 String s1 = "xyz"; 這樣的表達是建立字符串的時候(非new這種方式),程序首先會在這個 String 緩衝池中尋找相同值的對象,
在 String str1 = "xyz"; 中,s1 先被放到了池中,因此在 s2 被建立的時候,程序找到了具備相同值的 str1
並將 s2 引用 s1 所引用的對象 "xyz"
equals()
equals() 是object的方法,默認狀況下,它與== 同樣,比較的地址。
可是當equal被重載以後,根據設計,equal 會比較對象的value。而這個是java但願有的功能。String 類就重寫了這個方法
結果返回true
總的說,String 有個特色: 若是程序中有多個String對象,都包含相同的字符串序列,那麼這些String對象都映射到同一塊內存區域,因此兩次new String("hello")生成的兩個實例,雖然是相互獨立的,可是對它們使用hashCode()應該是一樣的結果。Note: 字符串數組並不是這樣,只有String是這樣。即hashCode對於String,是基於其內容的。
public class StringHashCode { public static void main(String[] args) { \\輸出結果相同 String[] hellos = "Hello Hello".split(" " ); System.out.println(""+hellos[0].hashCode()); System.out.println(""+hellos[1].hashCode()); \\輸出結果相同 String a = new String("hello"); String b = new String("hello"); System.out.println(""+a.hashCode()); System.out.println(""+b.hashCode()); } }
String 類是final類,不能夠繼承。對String類型最好的重用方式是組合 而不是繼承。
String 有length()方法,數組有length屬性
String s = new String("xyz"); 建立了幾個字符串對象?
兩個對象,一個靜態存儲區「xyz」, 一個用new建立在堆上的對象。
String 和 StringBuffer,String Builder區別?
在大部分狀況下 StringBuffer > String
Java.lang.StringBuffer 是線程安全的可變字符序列。一個相似於 String 的字符串緩衝區,但不能修改。雖然在任意時間點上它都包含某種特定的字符序列,但經過某些方法調用能夠改變該序列的長度和內容。在程序中可將字符串緩衝區安全地用於多線程。並且在必要時能夠對這些方法進行同步,所以任意特定實例上的全部操做就好像是以串行順序發生的,該順序與所涉及的每一個線程進行的方法調用順序一致。
StringBuffer 上的主要操做是 append 和 insert 方法,可重載這些方法,以接受任意類型的數據。每一個方法都能有效地將給定的數據轉換成字符串,而後將該字符串的字符追加或插入到字符串緩衝區中。append 方法始終將這些字符添加到緩衝區的末端;而 insert 方法則在指定的點添加字符。
例如,若是 z 引用一個當前內容是 「start"的字符串緩衝區對象,則此方法調用 z.append("le") 會使字符串緩衝區包含 「startle"( 累加); 而 z.insert(4, "le") 將更改字符串緩衝區,使之包含 「starlet"。
在大部分狀況下 StringBuilder > StringBuffer
java.lang.StringBuilder 一個可變的字符序列是 JAVA 5.0 新增的。此類提供一個與 StringBuffer 兼容的 API,但不保證同步,因此使用場景是單線程。該類被設計用做 StringBuffer 的一個簡易替換,用在字符串緩衝區被單個線程使用的時候(這種狀況很廣泛)。若是可能,建議優先採用該類,由於在大多數實現中,它比 StringBuffer 要快。二者的使用方法基本相同。
String,StringBuffer,StringBuilder都實現了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(); }
String的源碼
javapublic final class String{ private final char value[]; // used for character storage private int the hash; // cache the hash code for the string }
成員變量只有兩個:
final的char類型數組
int類型的hashcode
構造函數
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); }
這裏用到了一些工具函數copyOf(source[],length);
從源數組的0位置拷貝length個;
這個函數是用System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength))
實現的。
copyOfRange(T[] original, int from, int to)
。
構造函數還能夠用StringBuffer/StringBuilder類型初始化String,
javapublic 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()); }
除了構造方法,String類的方法有不少,length
,isEmpty
,能夠經過操做value.length來實現。charAt(int index)
:
經過操做value數組獲得。注意先判斷index的邊界條件
javapublic char charAt(int index) { if ((index < 0) || (index >= value.length)) { throw new StringIndexOutOfBoundsException(index); } return value[index]; }
getChars方法
javapublic void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) { \\邊界檢測 System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin); }
equals方法,根據語義相等(內容相等,而非指向同一塊內存),從新定義了equals
javapublic 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; }
若是比較的雙方指向同一塊內存,天然相等;(比較==便可)
若是內容相等,也相等,比較方法以下:
首先anObject得是String類型(用關鍵字instanceof)
而後再比較長度是否相等;
若是長度相等,則挨個元素進行比較,若是每一個都相等,則返回true.
還有現成安全的與StringBuffer內容比較contentEquals(StringBuffer sb)
,實現是在sb上使用同步。
compareTo()
:
若是A大於B,則返回大於0的數;
A小於B,則返回小於0的數;
A=B,則返回0
javapublic 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; }
regionMatches
:若是兩個字符串的區域都是平等的,
javapublic 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; }
startsWith(String prefix, int toffset)
startsWith(String prefix)
endsWith(String suffix)
java{ return startsWith(suffix, value.length - suffix.value.length); }
substring(int beginIndex,int endIndex)
除了條件判斷:
javareturn (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
字符串鏈接concat(String str)
javaint 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);
對於StringBuffer和StringBuilder
StringBuffer 和 StringBuilder 都是繼承於 AbstractStringBuilder, 底層的邏輯(好比append)都包含在這個類中。
javapublic AbstractStringBuilder append(String str) { if (str == null) str = "null"; int len = str.length(); ensureCapacityInternal(count + len);//查看使用空間知足,不知足擴展空間 str.getChars(0, len, value, count);//getChars就是利用native的array copy,性能高效 count += len; return this; }
StringBuffer 底層也是 char[], 數組初始化的時候就定下了大小, 若是不斷的 append 確定有超過數組大小的時候,咱們是否是定義一個超大容量的數組,太浪費空間了。就像 ArrayList 的實現,採用動態擴展,每次 append 首先檢查容量,容量不夠就先擴展,而後複製原數組的內容到擴展之後的數組中
想更一進步的支持我,請掃描下方的二維碼,你懂的~