String str = "abc"
等效於：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
charAt
public char charAt(int index)
返回指定索引處的 char 值。索引範圍爲從 0 到 length() - 1。序列的第一個 char 值在索引 0 處，第二個在索引 1 處，依此類推，這類似於數組索引。
參數：index - char 值的索引值。
返回：此字符串指定索引處的 char 值。第一個 char 值在索引 0 處。
拋出：IndexOutOfBoundsException - 如果 index 參數爲負或小於此字符串的長度。
例子：
String s = "Welcome to Java!";
char a;
StringBuffer b = new StringBuffer();
for (int i = 0; i < s.length(); i++) {
a = s.charAt(i);
b.append(a);
}
System.out.println(b);
其中關鍵的是如果把得到的字符放到字符串中，要用StringBuffer的append（char）方法，要不然就要直接打印出來
String s = "Welcome to Java!";
char a;
for (int i = 0; i < s.length(); i++) {
a = s.charAt(i);
System.out.print(a);
}
getChars
public void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
將字符從此字符串複製到目標字符數組。 要複製的第一個字符在索引 srcBegin 處；要複製的最後一個字符在索引 srcEnd-1 處（因此要複製的字符總數是 srcEnd-srcBegin）。要複製到 dst 子數組的字符從索引 dstBegin 處開始，並結束於索引： dstbegin + (srcEnd-srcBegin) - 1
參數：
srcBegin - 字符串中要複製的第一個字符的索引。
srcEnd - 字符串中要複製的最後一個字符之後的索引。
dst - 目標數組。
dstBegin - 目標數組中的起始偏移量。
拋出：
IndexOutOfBoundsException - 如果下列任何一項爲 true：
srcBegin 爲負。
srcBegin 大於 srcEnd
srcEnd 大於此字符串的長度
dstBegin 爲負
dstBegin+(srcEnd-srcBegin) 大於 dst.length
例子：其中關鍵的是定義字符串數組的時候要創建它的數組空間，如下例的char[20]，不然就會拋出異常
String s = "Welcome to Java!";
char []a = new char[20];
s.getChars(0, s.length(), a, 0);
System.out.println(a);
toCharArray
public char[] toCharArray()
將此字符串轉換爲一個新的字符數組。
返回：一個新分配的字符數組，它的長度是此字符串的長度，而且內容被初始化爲包含此字符串表示的字符序列。
例子：此方法與getChars()不同的是直接返回的就是字符數組，不需要爲字符數組指定空間
String s = "Welcome to Java!";
char []a = s.toCharArray();
System.out.println(a);
getBytes
public byte[] getBytes()
使用平臺默認的字符集將此 String 解碼爲字節序列，並將結果存儲到一個新的字節數組中。
當此字符串不能在默認的字符集中解碼時，該方法無指定的行爲。當需要進一步控制解碼過程時，應使用 CharsetEncoder 類。
返回：結果字節數組
例子：此程序就是把字符變成字節序列，然後再把字節序列變成字符
String s = "Welcome to Java!";
byte[]a =new byte[20];
a=s.getBytes();
System.out.print(a);
String b =new String(a);
System.out.println(b);
equals
public boolean equals(Object anObject)
比較此字符串與指定的對象。當且僅當該參數不爲 null，並且是表示與此對象相同的字符序列的 String 對象時，結果才爲 true。
覆蓋：類 Object 中的 equals
參數：anObject - 與此 String 進行比較的對象。
返回：如果 String 相等，則返回 true；否則返回 false
例子：
String a = "Welcome to Java!";
String b = "Welcome to Java!";
boolean c = a.equals(b);
System.out.print(c);
compareTo
public int compareTo(String anotherString)
按字典順序比較兩個字符串。該比較基於字符串中各個字符的 Unicode 值。將此 String 對象表示的字符序列與參數字符串所表示的字符序列進行比較。
如果按字典順序，此 String 對象在參數字符串之前，則比較結果爲一個負整數。
如果按字典順序此 String 對象位於參數字符串之後，則比較結果爲一個正整數。
如果這兩個字符串相等，則結果爲 0；compareTo 只有在方法 equals(Object) 返回 true 時才返回 0。
這是字典排序的定義。
例子：當然結果爲0
String a = "Welcome";
String b = "Welcome";
int c = a.compareTo(b);
System.out.print(c);
如果這兩個字符串不同，則要麼它們在某個索引處具有不同的字符，該索引對二者均爲有效索引，要麼它們的長度不同，或者同時具備上述兩種情況。如果它們在一個或多個索引位置上具有不同的字符，假設 k 是這類索引的最小值；則按照 < 運算符確定的那個字符串在位置 k 上具有較小的值，其字典順序在其他字符串之前。這種情況下，compareTo 返回這兩個字符串在位置 k 處的兩個不同的 char 值，即值：
this.charAt(k)-anotherString.charAt(k)
例子：其中在相同的索引位置上，e跟E的char值相差32，所以結果爲32
如果是int c = b.compareTo(a)的話，結果爲-32。下面例子一樣
String a = "Welcome";
String b = "WelcomE";
int c = a.compareTo(b);
System.out.print(c);
如果它們沒有不同的索引位置，則較短字符串在字典順序上位於較長字符串的前面。這種情況下，compareTo 返回這兩個字符串長度的不同，即值：
this.length()-anotherString.length()
例子：其結果爲7-2=5
String a = "Welcome";
String b = "We";
int c = a.compareTo(b);
System.out.print(c);
總結：當它們在的索引位置對應的字符相同的時候纔會用到length，如果它們的索引位置對應的字符不同的時候，就會在不同的那個索引位置用上charAt。例如：
String a = "Welcome to";
String b = "Wel to";
int c = a.compareTo(b);
System.out.print(c);
因爲在第四個索引位置上它們的字符已經不同了，所以會用到charAt，結果是空格與字符c的char值相差67，結果就是67
參數：anotherString - 要比較的 String。
返回：如果參數字符串等於此字符串，則返回 0 值；如果按字典順序此字符串小於字符串參數，則返回一個小於 0 的值；如果按字典順序此字符串大於字符串參數，則返回一個大於 0 的值。
contentEquals
public boolean contentEquals(StringBuffer sb)
當且僅當此 String 表示與指定的 StringBuffer 相同的字符序列時，才返回 true。
參數：sb - 要比較的 StringBuffer。
返回：當且僅當此 String 表示與指定的 StringBuffer 相同的字符序列時，才返回 true；否則返回 false。
拋出： NullPointerException - 如果 sb 爲 null
例子：這個方法與equals()方法不同的是比較的類型不同
String a = "Welcome to Java";
StringBuffer b = new StringBuffer("welcome to Java");
boolean c = a.contentEquals(b);
System.out.print(c);
equalsIgnoreCase
public boolean equalsIgnoreCase(String anotherString)
將此 String 與另一個 String 進行比較，不考慮大小寫。如果兩個字符串的長度相等，並且兩個字符串中的相應字符都相等（忽略大小寫），則認爲這兩個字符串是相等的。
在忽略大小寫的情況下，如果下列至少一項爲 true，則認爲 c1 和 c2 這兩個字符相同。
這兩個字符相同（使用 == 運算符進行比較）。
對每個字符應用方法 Character.toUpperCase(char) 產生相同的結果。
對每個字符應用方法 Character.toLowerCase(char) 產生相同的結果。
參數：anotherString - 與此 String 進行比較的 String。
返回：如果參數不爲 null，且這兩個 String 在忽略大小寫時相等，則返回 true；否則返回 false。
這個方法唯一與equals()方法不同的就是忽略大小寫
compareToIgnoreCase
public int compareToIgnoreCase(String str)
此方法唯一跟compateToIgnoreCase()方法不同的就是忽略大小寫
regionMatches
public boolean regionMatches(【boolean ignoreCase】,int toffset,String other,int ooffset,int len)
測試兩個字符串區域是否相等。
將此 String 對象的子字符串與參數 other 的子字符串進行比較。如果這兩個子字符串表示的是相同的字符序列，則結果爲 true，【當且僅當 ignoreCase 爲 true 時忽略大小寫。當然這個參數是可要可不要的，當不要的時候默認是要比較大小寫的】要比較的 String 對象的子字符串從索引 toffset 處開始，長度爲 len。要比較的 other 的子字符串從索引 ooffset 處開始，長度爲 len。
參數：
ignoreCase - 如果爲 true，則比較字符時忽略大小寫。
toffset - 字符串中的子區域的起始偏移量。
other - 字符串參數。
toffset - 字符串參數中的子區域的起始偏移量。
len - 要比較的字符數。
返回：如果此字符串的指定子區域匹配字符串參數的指定子區域，則返回 true；否則返回 false。是否完全匹配或大小寫敏感取決於 ignoreCase 參數。
例子：這個程序的結果是false，因爲2代表就是起始偏移量從l開始之後的8個字符lcome to，在子字符中從起始偏移量3，即l開始，之後的8個字符是lcome ti，在最後的一個字符不相同，所以結果爲false
String a = "Welcome to";
String b = "We lcome ti";
boolean c = a.regionMatches(2, b, 3, 8);
System.out.print(c);
startsWith
public boolean startsWith(String prefix)
測試此字符串是否以指定的前綴開始。
參數：prefix - 前綴。
返回：如果該參數表示的字符序列是此字符串表示的字符序列的前綴，則爲 true；否則爲 false。還要注意，如果參數是空字符串，或者等於由 equals(Object) 方法確定的 String 對象，則返回 true。
例子：因爲前綴用空字符串表示，所以結果爲true，如果是Wel也爲true，但如果是Wec則爲false
String a = "Welcome to";
boolean c = a.startsWith("");
System.out.print(c);
endsWith
public boolean endsWith(String suffix)
測試此字符串是否以指定的後綴結束。
參數：suffix - 後綴。
返回：如果該參數表示的字符序列是此對象表示的字符序列的後綴，則返回 true；否則返回 false。注意，如果該參數是空字符串或等於由 equals(Object) 方法確定的 String 對象，則結果爲 true。例子跟startsWith差不多
hashCode
public int hashCode()
返回此字符串的哈希碼。String 對象的哈希碼按下列公式計算：
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 【使用 int 算法，這裏 s[i] 是字符串的第 i 個字符，n 是字符串的長度，^ 表示求冪。（空字符串的哈希碼爲 0。） 】
覆蓋：類 Object 中的 hashCode
返回：此對象的哈希碼值。
例子：結果爲哈希碼計算公式。。。。-2079982760
String a = "Welcome to Java!";
int c = a.hashCode();
System.out.print(c);
indexOf
public int indexOf(int ch/String str)
返回指定字符/子字符串在此字符串中第一次出現處的索引。
參數：ch - 一個字符（Unicode 代碼點）
str - 一個子字符串
返回：在該對象表示的字符序列中第一次出現該字符/子字符串的索引，如果未出現該字符/子字符串，則返回 -1。
例子：結果爲8
String a = "Welcome 45to Java";
int c = a.indexOf("45");
System.out.print(c);
indexOf
public int indexOf(int ch/String str,int fromIndex)
從指定的索引開始搜索，返回在此字符串中第一次出現指定字符/子字符串處的索引。
在此 String 對象表示的字符序列中，如果帶有值 ch 的字符/帶有str子字符串的索引不小於 fromIndex，則返回第一次出現該值的索引。在任何情況下，如果此字符串中沒有這樣的字符/字符串在位置 fromIndex 處或其後出現，則返回 -1。 所有索引都在 char 值中指定（Unicode 代碼單元）。
參數：ch - 一個字符（Unicode 代碼點）。
str - 一個子字符串。
fromIndex - 開始搜索的索引。 fromIndex 的值沒有限制。如果它爲負，它和 0 具有同樣的效 果：將搜索整個字符串。如果它大於此字符串的長度，則它具有等於此字符串長度的相同效果： 返回 -1。
返回：在此對象表示的字符序列中第一次出現的大於或等於 fromIndex 的字符/子字符串的索引，如果未出現該字符/子字符串，則返回 -1。
例子：結果爲8，其中字符是從第8個開始搜索與之相同的字符
String a = "Welcome 45to Java";
int c = a.indexOf("45",8);
System.out.print(c);
lastIndexOf
public int lastIndexOf(int ch/String str)
返回最後一次出現的指定字符/子字符串在此字符串中的索引。
參數：ch - 一個字符（Unicode 代碼點）
str - 一個子字符串
返回：在此對象表示的字符序列中最後一次出現該字符/子字符串的索引，如果未出現該字符，則返回 -1。
lastIndexOf
public int lastIndexOf(int ch/String str,int fromIndex)
從指定的索引處開始進行後向搜索，返回最後一次出現的指定字符/子字符創在此字符串中的索引。
參數：ch - 一個字符（Unicode 代碼點）。
str - 一個子字符串。
fromIndex - 開始搜索的索引。 fromIndex 的值沒有限制。如果它爲負，它和 0 具有同樣的效 果：將搜索整個字符串。如果它大於此字符串的長度，則它具有等於此字符串長度的相同效果： 返回 -1。
返回：在此對象表示的字符序列中最後一次出現的等於 fromIndex 索引的字符/子字符串，如果在該點之前未出現該字符/子字符串，則返回 -1。
例子不再重複
substring
public String substring(int beginIndex)
返回一個新的字符串，它是此字符串的一個子字符串。該子字符串始於指定索引處的字符，一直到此字符串末尾。
例如：
"unhappy".substring(2) returns "happy"
"Harbison".substring(3) returns "bison"
"emptiness".substring(9) returns "" 【an empty string】
參數：beginIndex - 開始處的索引（包括）。
返回：指定的子字符串。
拋出： IndexOutOfBoundsException - 如果 beginIndex 爲負或大於此 String 對象的長度
substring
public String substring(int beginIndex,int endIndex)
返回一個新字符串，它是此字符串的一個子字符串。該子字符串從指定的 beginIndex 處開始，一直到索引 endIndex - 1 處的字符。因此，該子字符串的長度爲 endIndex-beginIndex。
例如：
"hamburger".substring(4, 8) returns "urge"
"smiles".substring(1, 5) returns "mile"
參數：beginIndex - 開始處的索引（包括）。
endIndex - 結束處的索引（不包括）。索引的第一個位置是0
返回：指定的子字符串。
拋出： IndexOutOfBoundsException - 如果 beginIndex 爲負，或 endIndex 大於此 String 對象的長度，或 beginIndex 大於 endIndex。
concat
public String concat(String str)
將指定字符串聯到此字符串的結尾。如果參數字符串的長度爲 0，則返回此 String 對象。否則，創建一個新的 String 對象，用來表示由此 String 對象表示的字符序列和由參數字符串表示的字符序列串聯而成的字符序列。
例如：
"cares".concat("s") returns "caress"
"to".concat("get").concat("her") returns "together"
參數：str - 串聯到此 String 結尾的 String。
返回：一個字符串，它表示此對象的字符後面串聯字符串參數的字符。
replace
public String replace(char oldChar,char newChar)
返回一個新的字符串，它是通過用 newChar 替換此字符串中出現的所有 oldChar 而生成的。
如果 oldChar 在此 String 對象表示的字符序列中沒有出現，則返回對此 String 對象的引用。否則，創建一個新的 String 對象，用來表示與此 String 對象表示的字符序列相等的字符序列，除了每個出現的 oldChar 都被一個 newChar 替換之外。
例如：
"mesquite in your cellar".replace('e', 'o')
returns "mosquito in your collar"
"the war of baronets".replace('r', 'y')
returns "the way of bayonets"
"sparring with a purple porpoise".replace('p', 't')
returns "starring with a turtle tortoise"
"JonL".replace('q', 'x') returns "JonL" 【no change】
參數：oldChar - 原來的字符。
newChar - 新字符。
返回：一個從此字符串派生的字符串，方法是在每個出現 oldChar 的地方用 newChar 替換。
replace
public String replace(CharSequence target,CharSequence replacement)
使用指定的字面值替換序列替換此字符串匹配字面值目標序列的每個子字符串。該替換從此字符串的開始一直到結束。
例如：用 "b" 替換字符串 "aaa" 中的 "aa" 將生成 "ba" 而不是 "ab"。 下面例子的結果爲Welcome 45toVC。
String a = "Welcome 45to Java";
System.out.print(a.replace("Java", "VC"));
參數：target - 要被替換的 char 值序列
replacement - char 值的替換序列
返回：得到的字符串
拋出： NullPointerException - 如果 target 或 replacement 爲 null。
toLowerCase
public String toLowerCase()
使用默認語言環境的規則將此 String 中的所有字符都轉換爲小寫。這等效於調用 toLowerCase(Locale.getDefault())。
返回：要轉換爲小寫的 String。
toUpperCase
public String toUpperCase()
使用默認語言環境的規則將此 String 中的所有字符都轉換爲大寫。此方法等效於toUpperCase(Locale.getDefault())。
返回：要轉換爲大寫的 String
trim
public String trim()
返回字符串的副本，忽略前導空白和尾部空白。
如果此 String 對象表示一個空字符序列，或者此 String 對象表示的字符序列的第一個和最後一個字符的代碼都大於 '/u0020'（空格字符），則返回對此 String 對象的引用。 若字符串中沒有代碼大於 '/u0020' 的字符，則創建並返回一個表示空字符串的新的 String 對象。
否則，假定 k 爲代碼大於 '/u0020' 的第一個字符的索引，m 爲代碼大於 '/u0020' 的最後一個字符的索引。創建一個新的 String 對象，它表示此字符串中從索引 k 處的字符開始，到索引 m 處的字符結束的子字符串，也就是 this.substring(k, m+1) 的結果。
此方法用於截去字符串從頭到尾的空白（如上面所定義）。
返回：此字符串移除了前導和尾部空白的副本，如果沒有前導和尾部空白，則返回此字符串。
例如：結果是【Welcome 45to Java】它只把前導和爲不的空白去掉而已
String a = " Welcome 45to Java ";
System.out.print(a.trim());
toString
public String toString()
返回此對象本身（它已經是一個字符串！）。
覆蓋：類 Object 中的 toString
返回：字符串本身。
valueOf
public static String valueOf(Object obj)
返回 Object 參數的字符串表示形式。
參數：obj - 一個 Object。
返回：如果參數爲 null，則字符串等於 "null"；否則，返回 obj.toString() 的值。
例子：結果爲java.awt.Label[label0,0,0,0x0,invalid,align=left,text=Welcome to Java!]
因爲此valueOf()這個方法是靜態方法，所以在用String直接調用就可以了，即String.valueOf(Object)
Label label = new Label("Welcome to Java!");
System.out.println(String.valueOf(label));
valueOf
public static String valueOf(char[] data)
返回 char 數組參數的字符串表示形式。字符數組的內容已被複制，後續修改不會影響新創建的字符串
參數：data - char 數組。
返回：一個新分配的字符串，它表示包含在字符數組參數中的相同字符序列。
例子：
char []a = {'w','e','l','c','o','m','e'};
System.out.println(String.valueOf(a));
valueOf
public static String valueOf(char[] data,int offset,int count)
返回 char 數組參數的特定子數組的字符串表示形式。
offset 參數是子數組的第一個字符的索引。count 參數指定子數組的長度。字符數組的內容已被複制，後續修改不會影響新創建的字符串。
參數：
data - 字符數組。
offset - String 值的初始偏移量。
count - String 值的長度。
返回：一個字符串，它表示在字符數組參數的子數組中包含的字符序列。
拋出： IndexOutOfBoundsException - 如果 offset 爲負，或者 count 爲負，或者 offset+count 大於 data.length。
valueOf
public static String valueOf(boolean b/char c/int i/long l/float f/double d)
返回 boolean 參數的字符串表示形式。
返回 char 參數的字符串表示形式。
返回 int 參數的字符串表示形式。該表示形式恰好是單參數的 Integer.toString 方法返回的結果。
返回 long 參數的字符串表示形式。該表示形式恰好是單參數的 Long.toString 方法返回的結果。
返回 float 參數的字符串表示形式。該表示形式恰好是單參數的 Float.toString 方法返回的結果。
返回 double 參數的字符串表示形式。該表示形式恰好是單參數的 Double.toString 方法返回的結果。
參數：
b - 一個 boolean。
c - 一個 char。
i - 一個 int。
l - 一個 long。
f - 一個 float。
d - 一個 double
返回：
如果參數爲 true，返回一個等於 "true" 的字符串；否則，返回一個等於 "false" 的字符串。
一個長度爲 1 的字符串，它包含參數 c 的單個字符。
int 參數的字符串表示形式。
返回 long 參數的字符串表示形式。
float 參數的字符串表示形式。
double 參數的字符串表示形式。
總結：因爲有關valueOf()的所有方法都是static靜態方法，所以在調用這種方法的時候要用String直接調用，而不是實例對象。
