Java字串String類學習筆記1
今天來學習一下String類的原始碼，首先看一下String類，
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence
從String類的定義我們可以看出，該類是final修飾的不可變的類，它實現了序列化和Comparable及CharSequence介面。
- final修飾的String類，說明String所定義的字串的值是不可修改的。
String類中的變數
private final char value[];
在String中定義了一個私有的字元陣列value，它是final所修飾的，其中字元陣列的元素也是不可以修改的，該字元陣列的值是字元陣列中的字元。
private int hash;
hash變數是一個int型，該變數用來記錄字串的雜湊值。
字元陣列轉字串的方法
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
public static char[] copyOf(char[] original, int newLength) { char[] copy = new char[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }
該方法是String類的有參構造方法，引數為一個字元陣列，內部實現是呼叫了Arrays類的copyOf方法，第一個引數是字元陣列的內容，第二個是字元陣列的長度。
public class TestString {
public static void main(String[] args){
String str = "abc";
char[] a = {'a','b','c'};
System.out.print(new String(a,1,2));
}
}
執行結果bc
其中使用了String類的構造方法String(char[] a,int offset,int count)
public String(char value[], int offset, int count) {
if (offset < 0) {//對元素的索引做判斷
throw new StringIndexOutOfBoundsException(offset);
}
if (count <= 0) {
if (count < 0) {//對要擷取的子串長度做判斷
throw new StringIndexOutOfBoundsException(count);
}
if (offset <= value.length) {
this.value = "".value;
return;
}
}
// Note: offset or count might be near -1>>>1.
if (offset > value.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}//這一部分主要是實現子字串的構造
this.value = Arrays.copyOfRange(value, offset, offset+count);
}
呼叫Arrays類的copyOfRange方法，value就是原字元陣列，offset就是新字串在父字串中索引，offset+count是那個索引與要擷取的字串的個數的總和。
public static char[] copyOfRange(char[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
char[] copy = new char[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
copyOfRange方法中，首先是計算一下要構造的新字元陣列的長度，然後建立一個新的字元陣列，接著呼叫System.arraycopy方法。最後將構造好的子字串進行返回。
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
}
}
該String類的構造方法的引數是StringBuffer物件，因為StringBuffer類不是執行緒安全的，所以在呼叫Arrays.copyof的方法時給buffer物件添加了synchronized關鍵字來進行執行緒同步，保證多執行緒情況下的執行緒安全性。
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), builder.length());
}
該String類的構造方法是一個帶StringBuilder物件的引數，也是將StringBuilder物件的內容構造為String物件。因為StringBuilder是執行緒安全的，所以不需要新增synchronized關鍵字來保證執行緒同步。
public int length() {
return value.length;
}
length()方法返回字串的長度，返回值為int型別。（String物件在非NULL的情況下才可以呼叫該方法）
public boolean isEmpty() {
return value.length == 0;
}
isEmpty()方法用來判斷字串是否為空，當且僅當字串的長度為0時，該方法才返回true。（String物件在非NULL的情況下才可以呼叫該方法）
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
charAt(int index)方法，返回值型別為char型，字元，引數為字串的索引值是int型別，首先會判斷引數是否是合法的索引值，如果是合法的索引值，然後返回value[index]代表了該索引在字串中對應的字元。
getBytes(String charsetName)方法的例子：
public class TestString {
public static void main(String[] args){
String str = "張三";
try {
byte[] b = str.getBytes("utf-8");
//通過下面的方法是將上面位元組陣列的內容還原為字串
String utf_byte = new String(str.getBytes("utf-8"),"utf-8");
for(byte b1:b){
//將字串按照utf-8進行轉碼，返回的位元組陣列
System.out.print(b1);
}
System.out.println();
System.out.println(utf_byte);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
}
執行結果：前面是將字串轉為位元組陣列的內容，後面是將位元組陣列還原為原來的字串。
-27-68-96-28-72-119張三
public byte[] getBytes(String charsetName)
throws UnsupportedEncodingException {
if (charsetName == null) throw new NullPointerException();
return StringCoding.encode(charsetName, value, 0, value.length);
}
getBytes(String charsetName)方法是用來根據指定的字元編碼來返回對應的位元組陣列，其中呼叫了StringCoding類的encode方法。
static byte[] encode(String charsetName, char[] ca, int off, int len)
throws UnsupportedEncodingException
{
StringEncoder se = deref(encoder);//如果傳入的字符集為null則預設使用、、、、ISO-8859-1
String csn = (charsetName == null) ? "ISO-8859-1" : charsetName;
if ((se == null) || !(csn.equals(se.requestedCharsetName())
|| csn.equals(se.charsetName()))) {
se = null;
try {
Charset cs = lookupCharset(csn);
if (cs != null)
se = new StringEncoder(cs, csn);
} catch (IllegalCharsetNameException x) {}
if (se == null)
throw new UnsupportedEncodingException (csn);
set(encoder, se);
}
return se.encode(ca, off, len);
}
lookupCharset(String csn)該方法用來獲取字符集，首先會根據你傳入的字符集名稱來判斷是否支援，支援的情況下，會返回字符集的名稱，否則就會報異常。
private static Charset lookupCharset(String csn) {
if (Charset.isSupported(csn)) {
try {
return Charset.forName(csn);
} catch (UnsupportedCharsetException x) {
throw new Error(x);
}
}
return null;
}
前面有篇文章我說了關於Object類中的equals和hashcode方法，自定義的類如果不重寫equals和hashcode方法，那麼會預設呼叫根基類Object類中的equals方法和hashcode方法，下面我們閱讀一下String類重寫Object類的equals方法原始碼：
public boolean equals(Object anObject) {
if (this == anObject) {//先判斷當前引用物件this是否是Object型別
return true;
}//判斷當前this物件是否是String類的例項
if (anObject instanceof String) {
String anotherString = (String)anObject;//將Object物件強制轉換為String類物件
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;
}
接著說一下String類的物件和StringBuffer類的物件如何做equals，可能有人會說，String和StringBuffer做equals時，將StringBuffer轉為String型別就可以呼叫equals，如果你看了StringBuffer的原始碼，可以看到該類並沒有equals方法，所以你需要呼叫StringBuffer物件的toString()方法來將其轉為String型別，然後就是兩個String物件之間的equals呼叫。
上面是一種方法，我們還可以直接使用String類自帶的contentEquals(StringBuffer sb)方法來對比，下面我先展示原始碼，然後在分析原始碼：
public boolean contentEquals(StringBuffer sb) {
return contentEquals((CharSequence)sb);
}
該方法的引數就是一個StringBuffer的物件，通過比較StringBuffer物件和字串String的字元序列是否一致，來得到比較結果，當且僅當String物件的字元序列和StringBuffer物件的字元序列一致的情況下才會返回true。其餘情況返回false.
我們繼續看上面的contentEquals(StringBuffer sb)的原始碼，它的返回值是呼叫了另外一個方法，同名且引數不是同一個型別，屬於方法過載，繼續展示過載後的方法原始碼，引數是一個CharSequence物件。
public boolean contentEquals(CharSequence cs) {
// Argument is a StringBuffer, StringBuilder
if (cs instanceof AbstractStringBuilder) {//這個判斷不太明白
if (cs instanceof StringBuffer) {//判斷是否是StringBuffer物件
synchronized(cs) {//同步CharSequence物件
return nonSyncContentEquals((AbstractStringBuilder)cs);
}
} else {
return nonSyncContentEquals((AbstractStringBuilder)cs);
}
}
// Argument is a String
if (cs instanceof String) {
return equals(cs);
}
// Argument is a generic CharSequence
char v1[] = value;
int n = v1.length;
if (n != cs.length()) {
return false;
}
for (int i = 0; i < n; i++) {//一個字元字元做比較
if (v1[i] != cs.charAt(i)) {
return false;
}
}
return true;
}
AbstractStringBuilder該類是一個抽象類，JDK1.5引入，實現了介面Appendable, CharSequence。
不明白的點：
1.AbstractStringBuilder是一個抽象類，按照道理應該不會有例項，那麼怎麼會判斷CharSequence物件是否屬於AbstractStringBuilder物件？
public boolean equalsIgnoreCase(String anotherString) {
return (this == anotherString) ? true
: (anotherString != null)
&& (anotherString.value.length == value.length)
&& regionMatches(true, 0, anotherString, 0, value.length);
}
equalsIgnoreCase(String anotherString)該方法也是比較兩個字串，但是他會忽略字串的大小寫，如果equals，則返回true,否則返回false.
它的實現主要有三個方面;
1.使用==來比較兩個字串是否相等
2.使用toUpperCase()方法來全部轉為大寫比較
3.使用toLowerCase()方法來全部轉為小寫比較
其中使用了方法regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)來實現2和3的驗證，具體實現的原始碼如下所示：
public boolean regionMatches(boolean ignoreCase, int toffset,
String other, int ooffset, int len) {
char ta[] = value;//原字串的value
int to = toffset;//原字串要開始的索引
char pa[] = other.value;//引數字串的value
int po = ooffset;//引數字串要開始比較的索引
//邊緣校驗 Note: toffset, ooffset, or len might be near -1>>>1.
if ((ooffset < 0) || (toffset < 0)
|| (toffset > (long)value.length - len)
|| (ooffset > (long)other.value.length - len)) {
return false;
}
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;
}
regionMatches方法主要是對比兩個字串是否相等，其中有5個引數，分別是
1.ignoreCase：如果該值為true，則在比較兩個字串的時候會忽略大小寫；
2.toffset：代表了字串的起始索引位置；
3.other：代表了該方法中的引數字串String；
4.ooffset：代表引數字串的起始索引；
5.len：表示兩個字串要對比的字元個數。
下面看一下String類的compareTo方法：
比較兩個字串中的字元是否一致。它是基於字串中每個字元的unicode值來做比較的。
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;
}
首先來看一下JDK中compareTo的原始碼的實現：
1.獲取兩個字串的長度；
2.用變數lim來記錄兩個字串長度中較小的一個字串長度值；
3.用兩個字元陣列v1和v2分別來儲存原來兩個字串的內容；
4.定義變數int型別k，初始化為0，並且以k<=lim為迴圈條件，對兩個字元陣列中同一索引的字元進行比較，如果不等，則直接return 兩個字元的unicode差值 結束迴圈；此處之所以用兩個字串長度較小的作為最高限，是防止下面兩個字元陣列訪問時出現數組越界的問題；
5.如果while迴圈順利通過，compareTo方法最後的返回值是兩個字串長度的差值。
其實我覺得這個實現的話，我覺得應該是這樣的：
上述步驟1之後，我們可以比較一下兩個字串的長度，如果當長度不相等的時候，我們就可以直接返回兩個長度的差值，我覺得長度都不相等的兩個字串，那麼一定是不會equals的。
當兩個字串長度相等的時候再用下面的while迴圈逐個字元比較unicode值，如果全部相等，則返回兩個字串長度的差值，否則當兩個字元的unicode值不相等的時候直接返回該對字元的unicode差值。
下面是幾組例子來說明compareTo方法：
public class TestString {
public static void main(String[] args){
String str1 = "abc";
String str2 = "abc";
String str3 = "abe";
String str4 = "abcde";
//結果為0
System.out.println(str1.compareTo(str2));
//結果為-2
System.out.println(str1.compareTo(str3));
//c和e分別對應的數值是12 14
System.out.println(Character.getNumericValue('c') + " " + Character.getNumericValue('e'));
//結果為-2
System.out.println(Character.getNumericValue('c')-Character.getNumericValue('e'));
//結果為-2
System.out.println(str1.compareTo(str4));
}
}
public int compareToIgnoreCase(String str) {
return CASE_INSENSITIVE_ORDER.compare(this, str);
}
compareToIgnoreCase(String str) 該方法引數為String型別，忽略字串的大小寫，返回結果類似於compare的結果，具體的實現是因為呼叫了toUpperCase和toLowerCase兩個方法。具體可以看原始碼的實現。
public boolean regionMatches(int toffset, String other, int ooffset,
int len) {
char ta[] = value;
int to = toffset;
char pa[] = other.value;
int po = ooffset;
// Note: toffset, ooffset, or len might be near -1>>>1.
if ((ooffset < 0) || (toffset < 0)
|| (toffset > (long)value.length - len)
|| (ooffset > (long)other.value.length - len)) {
return false;
}
while (len-- > 0) {
if (ta[to++] != pa[po++]) {
return false;
}
}
return true;
}
regionMatches(int toffset, String other, int ooffset, int len) 該方法是用來比較兩個字串是否相等，下面對於方法引數進行一下說明：
1.toffset ：表示當前物件的開始索引；
2.other ：表示方法引數裡面的String字串；
3.ooffset ：表示引數String字串要開始的索引；
4.len :表示兩個字串要比較的字元個數。
原理也是判斷完邊界條件之後，對兩個字串的相同位置的索引的字元進行對比，來判斷是否字串相等，它有一個過載的方法，忽略字串的大小寫，在前面提到過，多了一個boolean型別的引數，當值為true的時候，就會按照忽略大小寫進行比較字串。