java.lang
類 String
java.lang.Object
繼承者 java.lang.String
所有已實現的接口：
Serializable, CharSequence, Comparable<String>
--------------------------------------------------------------------------------
public final class Stringextends Objectimplements Serializable, Comparable<String>, CharSequenceString 類代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作爲此類的實例實現。
字符串是常量；它們的值在創建之後不能更改。字符串緩衝區支持可變的字符串。因爲 String 對象是不可變的，所以可以共享。例如：
String str = "abc";
等效於：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
下面給出了一些如何使用字符串的更多示例：
System.out.println("abc");
String cde = "cde";
System.out.println("abc" + cde);
String c = "abc".substring(2,3);
String d = cde.substring(1, 2);
String 類包括的方法可用於檢查序列的單個字符、比較字符串、搜索字符串、提取子字符串、創建字符串副本並將所有字符全部轉換爲大寫或小寫。大小寫映射基於 Character 類指定的 Unicode 標準版。
Java 語言提供對字符串串聯符號（"+"）以及將其他對象轉換爲字符串的特殊支持。字符串串聯是通過 StringBuilder（或 StringBuffer）類及其 append 方法實現的。字符串轉換是通過 toString 方法實現的，該方法由 Object 類定義，並可被 Java 中的所有類繼承。有關字符串串聯和轉換的更多信息，請參閱 Gosling、Joy 和 Steele 合著的 The Java Language Specification。
除非另行說明，否則將 null 參數傳遞給此類中的構造方法或方法將拋出 NullPointerException。
String 表示一個 UTF-16 格式的字符串，其中的增補字符 由代理項對 表示（有關詳細信息，請參閱 Character 類中的 Unicode 字符表示形式）。索引值是指 char 代碼單元，因此增補字符在 String 中佔用兩個位置。
String 類提供處理 Unicode 代碼點（即字符）和 Unicode 代碼單元（即 char 值）的方法。
從以下版本開始：
JDK1.0
另請參見：
Object.toString(), StringBuffer, StringBuilder, Charset, 序列化表格
--------------------------------------------------------------------------------
字段摘要
static Comparator<String> CASE_INSENSITIVE_ORDER
一個對 String 對象進行排序的 Comparator，作用與 compareToIgnoreCase 相同。
構造方法摘要
String()
初始化一個新創建的 String 對象，使其表示一個空字符序列。
String(byte[] bytes)
通過使用平臺的默認字符集解碼指定的 byte 數組，構造一個新的 String。
String(byte[] bytes, Charset charset)
通過使用指定的 charset 解碼指定的 byte 數組，構造一個新的 String。
String(byte[] ascii, int hibyte)
已過時。 該方法無法將字節正確地轉換爲字符。從 JDK 1.1 開始，完成該轉換的首選方法是使用帶有 Charset、字符集名稱，或使用平臺默認字符集的 String 構造方法。
String(byte[] bytes, int offset, int length)
通過使用平臺的默認字符集解碼指定的 byte 子數組，構造一個新的 String。
String(byte[] bytes, int offset, int length, Charset charset)
通過使用指定的 charset 解碼指定的 byte 子數組，構造一個新的 String。
String(byte[] ascii, int hibyte, int offset, int count)
已過時。 該方法無法將字節正確地轉換爲字符。從 JDK 1.1 開始，完成該轉換的首選方法是使用帶有 Charset、字符集名稱，或使用平臺默認字符集的 String 構造方法。
String(byte[] bytes, int offset, int length, String charsetName)
通過使用指定的字符集解碼指定的 byte 子數組，構造一個新的 String。
String(byte[] bytes, String charsetName)
通過使用指定的 charset 解碼指定的 byte 數組，構造一個新的 String。
String(char[] value)
分配一個新的 String，使其表示字符數組參數中當前包含的字符序列。
String(char[] value, int offset, int count)
分配一個新的 String，它包含取自字符數組參數一個子數組的字符。
String(int[] codePoints, int offset, int count)
分配一個新的 String，它包含 Unicode 代碼點數組參數一個子數組的字符。
String(String original)
初始化一個新創建的 String 對象，使其表示一個與參數相同的字符序列；換句話說，新創建的字符串是該參數字符串的副本。
String(StringBuffer buffer)
分配一個新的字符串，它包含字符串緩衝區參數中當前包含的字符序列。
String(StringBuilder builder)
分配一個新的字符串，它包含字符串生成器參數中當前包含的字符序列。
方法摘要
char charAt(int index)
返回指定索引處的 char 值。
int codePointAt(int index)
返回指定索引處的字符（Unicode 代碼點）。
int codePointBefore(int index)
返回指定索引之前的字符（Unicode 代碼點）。
int codePointCount(int beginIndex, int endIndex)
返回此 String 的指定文本範圍中的 Unicode 代碼點數。
int compareTo(String anotherString)
按字典順序比較兩個字符串。
int compareToIgnoreCase(String str)
按字典順序比較兩個字符串，不考慮大小寫。
String concat(String str)
將指定字符串連接到此字符串的結尾。
boolean contains(CharSequence s)
當且僅當此字符串包含指定的 char 值序列時，返回 true。
boolean contentEquals(CharSequence cs)
將此字符串與指定的 CharSequence 比較。
boolean contentEquals(StringBuffer sb)
將此字符串與指定的 StringBuffer 比較。
static String copyValueOf(char[] data)
返回指定數組中表示該字符序列的 String。
static String copyValueOf(char[] data, int offset, int count)
返回指定數組中表示該字符序列的 String。
boolean endsWith(String suffix)
測試此字符串是否以指定的後綴結束。
boolean equals(Object anObject)
將此字符串與指定的對象比較。
boolean equalsIgnoreCase(String anotherString)
將此 String 與另一個 String 比較，不考慮大小寫。
static String format(Locale l, String format, Object... args)
使用指定的語言環境、格式字符串和參數返回一個格式化字符串。
static String format(String format, Object... args)
使用指定的格式字符串和參數返回一個格式化字符串。
byte[] getBytes()
使用平臺的默認字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
byte[] getBytes(Charset charset)
使用給定的 charset 將此 String 編碼到 byte 序列，並將結果存儲到新的 byte 數組。
void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)
已過時。 該方法無法將字符正確轉換爲字節。從 JDK 1.1 起，完成該轉換的首選方法是通過 getBytes() 方法，該方法使用平臺的默認字符集。
byte[] getBytes(String charsetName)
使用指定的字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
將字符從此字符串複製到目標字符數組。
int hashCode()
返回此字符串的哈希碼。
int indexOf(int ch)
返回指定字符在此字符串中第一次出現處的索引。
int indexOf(int ch, int fromIndex)
返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。
int indexOf(String str)
返回指定子字符串在此字符串中第一次出現處的索引。
int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。
String intern()
返回字符串對象的規範化表示形式。
boolean isEmpty()
當且僅當 length() 爲 0 時返回 true。
int lastIndexOf(int ch)
返回指定字符在此字符串中最後一次出現處的索引。
int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最後一次出現處的索引，從指定的索引處開始進行反向搜索。
int lastIndexOf(String str)
返回指定子字符串在此字符串中最右邊出現處的索引。
int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最後一次出現處的索引，從指定的索引開始反向搜索。
int length()
返回此字符串的長度。
boolean matches(String regex)
告知此字符串是否匹配給定的正則表達式。
int offsetByCodePoints(int index, int codePointOffset)
返回此 String 中從給定的 index 處偏移 codePointOffset 個代碼點的索引。
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
測試兩個字符串區域是否相等。
boolean regionMatches(int toffset, String other, int ooffset, int len)
測試兩個字符串區域是否相等。
String replace(char oldChar, char newChar)
返回一個新的字符串，它是通過用 newChar 替換此字符串中出現的所有 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)
使用指定的字面值替換序列替換此字符串所有匹配字面值目標序列的子字符串。
String replaceAll(String regex, String replacement)
使用給定的 replacement 替換此字符串所有匹配給定的正則表達式的子字符串。
String replaceFirst(String regex, String replacement)
使用給定的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串。
String[] split(String regex)
根據給定正則表達式的匹配拆分此字符串。
String[] split(String regex, int limit)
根據匹配給定的正則表達式來拆分此字符串。
boolean startsWith(String prefix)
測試此字符串是否以指定的前綴開始。
boolean startsWith(String prefix, int toffset)
測試此字符串從指定索引開始的子字符串是否以指定前綴開始。
CharSequence subSequence(int beginIndex, int endIndex)
返回一個新的字符序列，它是此序列的一個子序列。
String substring(int beginIndex)
返回一個新的字符串，它是此字符串的一個子字符串。
String substring(int beginIndex, int endIndex)
返回一個新字符串，它是此字符串的一個子字符串。
char[] toCharArray()
將此字符串轉換爲一個新的字符數組。
String toLowerCase()
使用默認語言環境的規則將此 String 中的所有字符都轉換爲小寫。
String toLowerCase(Locale locale)
使用給定 Locale 的規則將此 String 中的所有字符都轉換爲小寫。
String toString()
返回此對象本身（它已經是一個字符串！）。
String toUpperCase()
使用默認語言環境的規則將此 String 中的所有字符都轉換爲大寫。
String toUpperCase(Locale locale)
使用給定 Locale 的規則將此 String 中的所有字符都轉換爲大寫。
String trim()
返回字符串的副本，忽略前導空白和尾部空白。
static String valueOf(boolean b)
返回 boolean 參數的字符串表示形式。
static String valueOf(char c)
返回 char 參數的字符串表示形式。
static String valueOf(char[] data)
返回 char 數組參數的字符串表示形式。
static String valueOf(char[] data, int offset, int count)
返回 char 數組參數的特定子數組的字符串表示形式。
static String valueOf(double d)
返回 double 參數的字符串表示形式。
static String valueOf(float f)
返回 float 參數的字符串表示形式。
static String valueOf(int i)
返回 int 參數的字符串表示形式。
static String valueOf(long l)
返回 long 參數的字符串表示形式。
static String valueOf(Object obj)
返回 Object 參數的字符串表示形式。
從類 java.lang.Object 繼承的方法
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
字段詳細信息
CASE_INSENSITIVE_ORDER
public static final Comparator<String> CASE_INSENSITIVE_ORDER一個對 String 對象進行排序的 Comparator，作用與 compareToIgnoreCase 相同。此比較器是可序列化的。
注意，Comparator 不 考慮語言環境，因此可能導致在某些語言環境中的排序效果不理想。java.text 包提供 Collator 完成與語言環境有關的排序。
從以下版本開始：
1.2
另請參見：
Collator.compare(String, String)
構造方法詳細信息
String
public String()初始化一個新創建的 String 對象，使其表示一個空字符序列。注意，由於 String 是不可變的，所以無需使用此構造方法。
--------------------------------------------------------------------------------
String
public String(String original)初始化一個新創建的 String 對象，使其表示一個與參數相同的字符序列；換句話說，新創建的字符串是該參數字符串的副本。由於 String 是不可變的，所以無需使用此構造方法，除非需要 original 的顯式副本。
參數：
original - 一個 String。
--------------------------------------------------------------------------------
String
public String(char[] value)分配一個新的 String，使其表示字符數組參數中當前包含的字符序列。該字符數組的內容已被複制；後續對字符數組的修改不會影響新創建的字符串。
參數：
value - 字符串的初始值
--------------------------------------------------------------------------------
String
public String(char[] value,
int offset,
int count)分配一個新的 String，它包含取自字符數組參數一個子數組的字符。offset 參數是子數組第一個字符的索引，count 參數指定子數組的長度。該子數組的內容已被複制；後續對字符數組的修改不會影響新創建的字符串。
參數：
value - 作爲字符源的數組。
offset - 初始偏移量。
count - 長度。
拋出：
IndexOutOfBoundsException - 如果 offset 和 count 參數索引字符超出 value 數組的範圍。
--------------------------------------------------------------------------------
String
public String(int[] codePoints,
int offset,
int count)分配一個新的 String，它包含 Unicode 代碼點數組參數一個子數組的字符。offset 參數是該子數組第一個代碼點的索引，count 參數指定子數組的長度。將該子數組的內容轉換爲 char；後續對 int 數組的修改不會影響新創建的字符串。
參數：
codePoints - 作爲 Unicode 代碼點的源的數組。
offset - 初始偏移量。
count - 長度。
拋出：
IllegalArgumentException - 如果在 codePoints 中發現任何無效的 Unicode 代碼點
IndexOutOfBoundsException - 如果 offset 和 count 參數索引字符超出 codePoints 數組的範圍。
從以下版本開始：
1.5
--------------------------------------------------------------------------------
String
@Deprecated
public String(byte[] ascii,
int hibyte,
int offset,
int count)已過時。 該方法無法將字節正確地轉換爲字符。從 JDK 1.1 開始，完成該轉換的首選方法是使用帶有 Charset、字符集名稱，或使用平臺默認字符集的 String 構造方法。
分配一個新的 String，它是根據一個 8 位整數值數組的子數組構造的。
offset 參數是該子數組的第一個 byte 的索引，count 參數指定子數組的長度。
子數組中的每個 byte 都按照上述方法轉換爲 char。
參數：
ascii - 要轉換爲字符的 byte。
hibyte - 每個 16 位 Unicode 代碼單元的前 8 位。
offset - 初始偏移量。
count - 長度。
拋出：
IndexOutOfBoundsException - 如果 offset 或 count 參數無效。
另請參見：
String(byte[], int), String(byte[], int, int, java.lang.String), String(byte[], int, int, java.nio.charset.Charset), String(byte[], int, int), String(byte[], java.lang.String), String(byte[], java.nio.charset.Charset), String(byte[])
--------------------------------------------------------------------------------
String
@Deprecated
public String(byte[] ascii,
int hibyte)已過時。 該方法無法將字節正確地轉換爲字符。從 JDK 1.1 開始，完成該轉換的首選方法是使用帶有 Charset、字符集名稱，或使用平臺默認字符集的 String 構造方法。
分配一個新的 String，它包含根據一個 8 位整數值數組構造的字符。所得字符串中的每個字符 c 都是根據 byte 數組中的相應組件 b 構造的，如下所示：
c == (char)(((hibyte & 0xff) << 8)
| (b & 0xff))
參數：
ascii - 要轉換爲字符的 byte。
hibyte - 每個 16 位 Unicode 代碼單元的前 8 位。
另請參見：
String(byte[], int, int, java.lang.String), String(byte[], int, int, java.nio.charset.Charset), String(byte[], int, int), String(byte[], java.lang.String), String(byte[], java.nio.charset.Charset), String(byte[])
--------------------------------------------------------------------------------
String
public String(byte[] bytes,
int offset,
int length,
String charsetName)
throws UnsupportedEncodingException通過使用指定的字符集解碼指定的 byte 子數組，構造一個新的 String。新 String 的長度是一個字符集函數，因此可能不等於子數組的長度。
當給定 byte 在給定字符集中無效的情況下，此構造方法的行爲沒有指定。如果需要對解碼過程進行更多控制，則應該使用 CharsetDecoder 類。
參數：
bytes - 要解碼爲字符的 byte
offset - 要解碼的第一個 byte 的索引
length - 要解碼的 byte 數
charsetName - 受支持 charset 的名稱
拋出：
UnsupportedEncodingException - 如果指定的字符集不受支持
IndexOutOfBoundsException - 如果 offset 和 length 參數索引字符超出 bytes 數組的範圍
從以下版本開始：
JDK1.1
--------------------------------------------------------------------------------
String
public String(byte[] bytes,
int offset,
int length,
Charset charset)通過使用指定的 charset 解碼指定的 byte 子數組，構造一個新的 String。新 String 的長度是字符集的函數，因此可能不等於子數組的長度。
此方法總是使用此字符集的默認替代字符串替代錯誤輸入 (malformed-input) 和不可映射字符 (unmappable-character) 序列。如果需要對解碼過程進行更多控制，則應該使用 CharsetDecoder 類。
參數：
bytes - 要解碼爲字符的 byte
offset - 要解碼的第一個 byte 的索引
length - 要解碼的 byte 數
charset - 用來解碼 bytes 的 charset
拋出：
IndexOutOfBoundsException - 如果 offset 和 length 參數索引字符超出 bytes 數組的邊界
從以下版本開始：
1.6
--------------------------------------------------------------------------------
String
public String(byte[] bytes,
String charsetName)
throws UnsupportedEncodingException通過使用指定的 charset 解碼指定的 byte 數組，構造一個新的 String。新 String 的長度是字符集的函數，因此可能不等於 byte 數組的長度。
當給定 byte 在給定字符集中無效的情況下，此構造方法的行爲沒有指定。如果需要對解碼過程進行更多控制，則應該使用 CharsetDecoder 類。
參數：
bytes - 要解碼爲字符的 byte
charsetName - 受支持的 charset 的名稱
拋出：
UnsupportedEncodingException - 如果指定字符集不受支持
從以下版本開始：
JDK1.1
--------------------------------------------------------------------------------
String
public String(byte[] bytes,
Charset charset)通過使用指定的 charset 解碼指定的 byte 數組，構造一個新的 String。新 String 的長度是字符集的函數，因此可能不等於 byte 數組的長度。
此方法總是使用此字符集的默認替代字符串替代錯誤輸入和不可映射字符序列。如果需要對解碼過程進行更多控制，則應該使用 CharsetDecoder 類。
參數：
bytes - 要解碼爲字符的 byte
charset - 要用來解碼 bytes 的 charset
從以下版本開始：
1.6
--------------------------------------------------------------------------------
String
public String(byte[] bytes,
int offset,
int length)通過使用平臺的默認字符集解碼指定的 byte 子數組，構造一個新的 String。新 String 的長度是字符集的函數，因此可能不等於該子數組的長度。
當給定 byte 在給定字符集中無效的情況下，此構造方法的行爲沒有指定。如果需要對解碼過程進行更多控制，則應該使用 CharsetDecoder 類。
參數：
bytes - 要解碼爲字符的 byte
offset - 要解碼的第一個 byte 的索引
length - 要解碼的 byte 數
拋出：
IndexOutOfBoundsException - 如果 offset 和 length 參數索引字符超出 bytes 數組的範圍
從以下版本開始：
JDK1.1
--------------------------------------------------------------------------------
String
public String(byte[] bytes)通過使用平臺的默認字符集解碼指定的 byte 數組，構造一個新的 String。新 String 的長度是字符集的函數，因此可能不等於 byte 數組的長度。
當給定 byte 在給定字符集中無效的情況下，此構造方法的行爲沒有指定。如果需要對解碼過程進行更多控制，則應該使用 CharsetDecoder 類。
參數：
bytes - 要解碼爲字符的 byte
從以下版本開始：
JDK1.1
--------------------------------------------------------------------------------
String
public String(StringBuffer buffer)分配一個新的字符串，它包含字符串緩衝區參數中當前包含的字符序列。該字符串緩衝區的內容已被複制，後續對它的修改不會影響新創建的字符串。
參數：
buffer - 一個 StringBuffer
--------------------------------------------------------------------------------
String
public String(StringBuilder builder)分配一個新的字符串，它包含字符串生成器參數中當前包含的字符序列。該字符串生成器的內容已被複制，後續對它的修改不會影響新創建的字符串。
提供此構造方法是爲了簡化到 StringBuilder 的遷移。通過 toString 方法從字符串生成器中獲取字符串可能運行的更快，因此通常作爲首選。
參數：
builder - 一個 StringBuilder
從以下版本開始：
1.5
方法詳細信息
length
public int length()返回此字符串的長度。長度等於字符串中 Unicode 代碼單元的數量。
指定者：
接口 CharSequence 中的 length
返回：
此對象表示的字符序列的長度。
--------------------------------------------------------------------------------
isEmpty
public boolean isEmpty()當且僅當 length() 爲 0 時返回 true。
返回：
如果 length() 爲 0，則返回 true；否則返回 false。
從以下版本開始：
1.6
--------------------------------------------------------------------------------
charAt
public char charAt(int index)返回指定索引處的 char 值。索引範圍爲從 0 到 length() - 1。序列的第一個 char 值位於索引 0 處，第二個位於索引 1 處，依此類推，這類似於數組索引。
如果索引指定的 char 值是代理項，則返回代理項值。
指定者：
接口 CharSequence 中的 charAt
參數：
index - char 值的索引。
返回：
此字符串指定索引處的 char 值。第一個 char 值位於索引 0 處。
拋出：
IndexOutOfBoundsException - 如果 index 參數爲負或小於此字符串的長度。
--------------------------------------------------------------------------------
codePointAt
public int codePointAt(int index)返回指定索引處的字符（Unicode 代碼點）。索引引用 char 值（Unicode 代碼單元），其範圍從 0 到 length() - 1。
如果給定索引指定的 char 值屬於高代理項範圍，則後續索引小於此 String 的長度；如果後續索引處的 char 值屬於低代理項範圍，則返回該代理項對相應的增補代碼點。否則，返回給定索引處的 char 值。
參數：
index - char 值的索引
返回：
index 處字符的代碼點值
拋出：
IndexOutOfBoundsException - 如果 index 參數爲負或小於此字符串的長度。
從以下版本開始：
1.5
--------------------------------------------------------------------------------
codePointBefore
public int codePointBefore(int index)返回指定索引之前的字符（Unicode 代碼點）。索引引用 char 值（Unicode 代碼單元），其範圍從 1 到 length。
如果 (index - 1) 處的 char 值屬於低代理項範圍，則 (index - 2) 爲非負；如果 (index - 2) 處的 char 值屬於高低理項範圍，則返回該代理項對的增補代碼點值。如果 index - 1 處的 char 值是未配對的低（高）代理項，則返回代理項值。
參數：
index - 應返回的代碼點之後的索引
返回：
給定索引前面的 Unicode 代碼點。
拋出：
IndexOutOfBoundsException - 如果 index 參數小於 1 或大於此字符串的長度。
從以下版本開始：
1.5
--------------------------------------------------------------------------------
codePointCount
public int codePointCount(int beginIndex,
int endIndex)返回此 String 的指定文本範圍中的 Unicode 代碼點數。文本範圍始於指定的 beginIndex，一直到索引 endIndex - 1 處的 char。因此，該文本範圍的長度（用 char 表示）是 endIndex-beginIndex。該文本範圍內每個未配對的代理項計爲一個代碼點。
參數：
beginIndex - 文本範圍的第一個 char 的索引。
endIndex - 文本範圍的最後一個 char 之後的索引。
返回：
指定文本範圍中 Unicode 代碼點的數量
拋出：
IndexOutOfBoundsException - 如果 beginIndex 爲負，或 endIndex 大於此 String 的長度，或 beginIndex 大於 endIndex。
從以下版本開始：
1.5
--------------------------------------------------------------------------------
offsetByCodePoints
public int offsetByCodePoints(int index,
int codePointOffset)返回此 String 中從給定的 index 處偏移 codePointOffset 個代碼點的索引。文本範圍內由 index 和 codePointOffset 給定的未配對代理項各計爲一個代碼點。
參數：
index - 要偏移的索引
codePointOffset - 代碼點中的偏移量
返回：
String 的索引
拋出：
IndexOutOfBoundsException - 如果 index 爲負或大於此 String 的長度；或者 codePointOffset 爲正，且以 index 開頭子字符串的代碼點比 codePointOffset 少；如果 codePointOffset 爲負，且 index 前面子字符串的代碼點比 codePointOffset 的絕對值少。
從以下版本開始：
1.5
--------------------------------------------------------------------------------
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
--------------------------------------------------------------------------------
getBytes
@Deprecated
public void getBytes(int srcBegin,
int srcEnd,
byte[] dst,
int dstBegin)已過時。 該方法無法將字符正確轉換爲字節。從 JDK 1.1 起，完成該轉換的首選方法是通過 getBytes() 方法，該方法使用平臺的默認字符集。
將字符從此字符串複製到目標 byte 數組中。每個 byte 接收相應字符的 8 個低位。不復制每個字符的高位，它們不參與任何方式的轉換。
要複製的第一個字符位於索引 srcBegin 處；要複製的最後一個字符位於索引 srcEnd-1 處。要複製的字符總數爲 srcEnd-srcBegin。將轉換爲 byte 的字符複製到 dst 的子數組中，從索引 dstBegin 處開始，並結束於索引：
dstbegin + (srcEnd-srcBegin) - 1
參數：
srcBegin - 字符串中要複製的第一個字符的索引
srcEnd - 字符串中要複製的最後一個字符之後的索引
dst - 目標數組
dstBegin - 目標數組中的起始偏移量
拋出：
IndexOutOfBoundsException - 如果下列任何一項爲 true：
srcBegin 爲負
srcBegin 大於 srcEnd
srcEnd 大於此 String 的長度
dstBegin 爲負
dstBegin+(srcEnd-srcBegin) 大於 dst.length
--------------------------------------------------------------------------------
getBytes
public byte[] getBytes(String charsetName)
throws UnsupportedEncodingException使用指定的字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
當此字符串不能使用給定的字符集編碼時，此方法的行爲沒有指定。如果需要對編碼過程進行更多控制，則應該使用 CharsetEncoder 類。
參數：
charsetName - 受支持的 charset 名稱
返回：
所得 byte 數組
拋出：
UnsupportedEncodingException - 如果指定的字符集不受支持
從以下版本開始：
JDK1.1
--------------------------------------------------------------------------------
getBytes
public byte[] getBytes(Charset charset)使用給定的 charset 將此 String 編碼到 byte 序列，並將結果存儲到新的 byte 數組。
此方法總是使用此字符集的默認替代 byte 數組替代錯誤輸入和不可映射字符序列。如果需要對編碼過程進行更多控制，則應該使用 CharsetEncoder 類。
參數：
charset - 用於編碼 String 的 Charset
返回：
所得 byte 數組
從以下版本開始：
1.6
--------------------------------------------------------------------------------
getBytes
public byte[] getBytes()使用平臺的默認字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
當此字符串不能使用默認的字符集編碼時，此方法的行爲沒有指定。如果需要對編碼過程進行更多控制，則應該使用 CharsetEncoder 類。
返回：
所得 byte 數組
從以下版本開始：
JDK1.1
--------------------------------------------------------------------------------
equals
public boolean equals(Object anObject)將此字符串與指定的對象比較。當且僅當該參數不爲 null，並且是與此對象表示相同字符序列的 String 對象時，結果才爲 true。
覆蓋：
類 Object 中的 equals
參數：
anObject - 與此 String 進行比較的對象。
返回：
如果給定對象表示的 String 與此 String 相等，則返回 true；否則返回 false。
另請參見：
compareTo(String), equalsIgnoreCase(String)
--------------------------------------------------------------------------------
contentEquals
public boolean contentEquals(StringBuffer sb)將此字符串與指定的 StringBuffer 比較。當且僅當此 String 與指定 StringBuffer 表示相同的字符序列時，結果才爲 true。
參數：
sb - 要與此 String 比較的 StringBuffer。
返回：
如果此 String 與指定 StringBuffer 表示相同的字符序列，則返回 true；否則返回 false。
從以下版本開始：
1.4
--------------------------------------------------------------------------------
contentEquals
public boolean contentEquals(CharSequence cs)將此字符串與指定的 CharSequence 比較。當且僅當此 String 與指定序列表示相同的 char 值序列時，結果才爲 true。
參數：
cs - 要與此 String 比較的序列
返回：
如果此 String 與指定序列表示相同的 char 值序列，則返回 true；否則返回 false。
從以下版本開始：
1.5
--------------------------------------------------------------------------------
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(Object)
--------------------------------------------------------------------------------
compareTo
public int compareTo(String anotherString)按字典順序比較兩個字符串。該比較基於字符串中各個字符的 Unicode 值。按字典順序將此 String 對象表示的字符序列與參數字符串所表示的字符序列進行比較。如果按字典順序此 String 對象位於參數字符串之前，則比較結果爲一個負整數。如果按字典順序此 String 對象位於參數字符串之後，則比較結果爲一個正整數。如果這兩個字符串相等，則結果爲 0；compareTo 只在方法 equals(Object) 返回 true 時才返回 0。
這是字典排序的定義。如果這兩個字符串不同，那麼它們要麼在某個索引處的字符不同（該索引對二者均爲有效索引），要麼長度不同，或者同時具備這兩種情況。如果它們在一個或多個索引位置上的字符不同，假設 k 是這類索引的最小值；則在位置 k 上具有較小值的那個字符串（使用 < 運算符確定），其字典順序在其他字符串之前。在這種情況下，compareTo 返回這兩個字符串在位置 k 處兩個char 值的差，即值：
this.charAt(k)-anotherString.charAt(k)
如果沒有字符不同的索引位置，則較短字符串的字典順序在較長字符串之前。在這種情況下，compareTo 返回這兩個字符串長度的差，即值：
this.length()-anotherString.length()
指定者：
接口 Comparable<String> 中的 compareTo
參數：
anotherString - 要比較的 String。
返回：
如果參數字符串等於此字符串，則返回值 0；如果此字符串按字典順序小於字符串參數，則返回一個小於 0 的值；如果此字符串按字典順序大於字符串參數，則返回一個大於 0 的值。
--------------------------------------------------------------------------------
compareToIgnoreCase
public int compareToIgnoreCase(String str)按字典順序比較兩個字符串，不考慮大小寫。此方法返回一個整數，其符號與使用規範化的字符串調用 compareTo 所得符號相同，規範化字符串的大小寫差異已通過對每個字符調用 Character.toLowerCase(Character.toUpperCase(character)) 消除。
注意，此方法不 考慮語言環境，因此可能導致在某些語言環境中的排序效果不理想。java.text 包提供 Collators 完成與語言環境有關的排序。
參數：
str - 要比較的 String。
返回：
根據指定 String 大於、等於還是小於此 String（不考慮大小寫），分別返回一個負整數、0 或一個正整數。
從以下版本開始：
1.2
另請參見：
Collator.compare(String, String)
--------------------------------------------------------------------------------
regionMatches
public boolean regionMatches(int toffset,
String other,
int ooffset,
int len)測試兩個字符串區域是否相等。
將此 String 對象的一個子字符串與參數 other 的一個子字符串進行比較。如果這兩個子字符串表示相同的字符序列，則結果爲 true。要比較的此 String 對象的子字符串從索引 toffset 處開始，長度爲 len。要比較的 other 的子字符串從索引 ooffset 處開始，長度爲 len。當且僅當下列至少一項爲 true 時，結果才爲 false ：
toffset 爲負。
ooffset 爲負。
toffset+len 大於此 String 對象的長度。
ooffset+len 大於另一個參數的長度。
存在某個小於 len 的非負整數 k，它滿足：this.charAt(toffset+k) != other.charAt(ooffset+k)
參數：
toffset - 字符串中子區域的起始偏移量。
other - 字符串參數。
ooffset - 字符串參數中子區域的起始偏移量。
len - 要比較的字符數。
返回：
如果此字符串的指定子區域完全匹配字符串參數的指定子區域，則返回 true；否則返回 false。
--------------------------------------------------------------------------------
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。當且僅當下列至少一項爲 true 時，結果才爲 false：
toffset 爲負。
ooffset 爲負。
toffset+len 大於此 String 對象的長度。
ooffset+len 大於另一個參數的長度。
ignoreCase 爲 false，且存在某個小於 len 的非負整數 k，即：
this.charAt(toffset+k) != other.charAt(ooffset+k)
ignoreCase 爲 true，且存在某個小於 len 的非負整數 k，即：
Character.toLowerCase(this.charAt(toffset+k)) !=
Character.toLowerCase(other.charAt(ooffset+k))
以及：
Character.toUpperCase(this.charAt(toffset+k)) !=
Character.toUpperCase(other.charAt(ooffset+k))
參數：
ignoreCase - 如果爲 true，則比較字符時忽略大小寫。
toffset - 此字符串中子區域的起始偏移量。
other - 字符串參數。
toffset - 字符串參數中子區域的起始偏移量。
len - 要比較的字符數。
返回：
如果此字符串的指定子區域匹配字符串參數的指定子區域，則返回 true；否則返回 false。是否完全匹配或考慮大小寫取決於 ignoreCase 參數。
--------------------------------------------------------------------------------
startsWith
public boolean startsWith(String prefix,
int toffset)測試此字符串從指定索引開始的子字符串是否以指定前綴開始。
參數：
prefix - 前綴。
toffset - 在此字符串中開始查找的位置。
返回：
如果參數表示的字符序列是此對象從索引 toffset 處開始的子字符串前綴，則返回 true；否則返回 false。如果 toffset 爲負或大於此 String 對象的長度，則結果爲 false；否則結果與以下表達式的結果相同：
this.substring(toffset).startsWith(prefix)
--------------------------------------------------------------------------------
startsWith
public boolean startsWith(String prefix)測試此字符串是否以指定的前綴開始。
參數：
prefix - 前綴。
返回：
如果參數表示的字符序列是此字符串表示的字符序列的前綴，則返回 true；否則返回 false。還要注意，如果參數是空字符串，或者等於此 String 對象（用 equals(Object) 方法確定），則返回 true。
從以下版本開始：
1. 0
--------------------------------------------------------------------------------
endsWith
public boolean endsWith(String suffix)測試此字符串是否以指定的後綴結束。
參數：
suffix - 後綴。
返回：
如果參數表示的字符序列是此對象表示的字符序列的後綴，則返回 true；否則返回 false。注意，如果參數是空字符串，或者等於此 String 對象（用 equals(Object) 方法確定），則結果爲 true。
--------------------------------------------------------------------------------
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
返回：
此對象的哈希碼值。
另請參見：
Object.equals(java.lang.Object), Hashtable
--------------------------------------------------------------------------------
indexOf
public int indexOf(int ch)返回指定字符在此字符串中第一次出現處的索引。如果在此 String 對象表示的字符序列中出現值爲 ch 的字符，則返回第一次出現該字符的索引（以 Unicode 代碼單元表示）。對於 0 到 0xFFFF（包括 0 和 0xFFFF）範圍內的 ch 的值，返回值是
this.charAt(k) == ch
爲 true 的最小 k 值。對於其他 ch 值，返回值是
this.codePointAt(k) == ch
爲 true 最小 k 值。無論哪種情況，如果此字符串中沒有這樣的字符，則返回 -1。
參數：
ch - 一個字符（Unicode 代碼點）。
返回：
在此對象表示的字符序列中第一次出現該字符的索引；如果未出現該字符，則返回 -1。
--------------------------------------------------------------------------------
indexOf
public int indexOf(int ch,
int fromIndex)返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。
在此 String 對象表示的字符序列中，如果帶有值 ch 的字符的索引不小於 fromIndex，則返回第一次出現該值的索引。對於 0 到 0xFFFF（包括 0 和 0xFFFF）範圍內的 ch 值，返回值是
(this.charAt(k) == ch) && (k >= fromIndex)
爲 true 的最小 k 值。對於其他 ch 值，返回值是
(this.codePointAt(k) == ch) && (k >= fromIndex)
爲 true 的最小 k 值。無論哪種情況，如果此字符串中 fromIndex 或之後的位置沒有這樣的字符出現，則返回 -1。
fromIndex 的值沒有限制。如果它爲負，則與它爲 0 的效果同樣：將搜索整個字符串。如果它大於此字符串的長度，則與它等於此字符串長度的效果相同：返回 -1。
所有索引都在 char 值中指定（Unicode 代碼單元）。
參數：
ch - 一個字符（Unicode 代碼點）。
fromIndex - 開始搜索的索引。
返回：
在此對象表示的字符序列中第一次出現的大於或等於 fromIndex 的字符的索引；如果未出現該字符，則返回 -1。
--------------------------------------------------------------------------------
lastIndexOf
public int lastIndexOf(int ch)返回指定字符在此字符串中最後一次出現處的索引。對於 0 到 0xFFFF（包括 0 和 0xFFFF）範圍內的 ch 的值，返回的索引（Unicode 代碼單元）是
this.charAt(k) == ch
爲 true 最大 k 值。對於其他 ch 值，返回值是
this.codePointAt(k) == ch
爲 true 的最大 k 值。無論哪種情況，如果此字符串中沒有這樣的字符出現，則返回 -1。從最後一個字符開始反向搜索此 String。
參數：
ch - 一個字符（Unicode 代碼點）。
返回：
在此對象表示的字符序列中最後一次出現該字符的索引；如果未出現該字符，則返回 -1。
--------------------------------------------------------------------------------
lastIndexOf
public int lastIndexOf(int ch,
int fromIndex)返回指定字符在此字符串中最後一次出現處的索引，從指定的索引處開始進行反向搜索。對於 0 到 0xFFFF（包括 0 和 0xFFFF）範圍內的 ch 值，返回的索引是
(this.charAt(k) == ch) && (k <= fromIndex)
爲 true 的最大 k 值。對於 ch 的其他值，返回值是
(this.codePointAt(k) == ch) && (k <= fromIndex)
爲 true 的最大 k 值。無論哪種情況，如果此字符串中 fromIndex 或之前的位置沒有這樣的字符出現，則返回 -1。
所有的索引都以 char 值指定（Unicode 代碼單元）。
參數：
ch - 一個字符（Unicode 代碼點）。
fromIndex - 開始搜索的索引。fromIndex 的值沒有限制。如果它大於等於此字符串的長度，則與它小於此字符串長度減 1 的效果相同：將搜索整個字符串。如果它爲負，則與它爲 -1 的效果相同：返回 -1。
返回：
在此對象表示的字符序列（小於等於 fromIndex）中最後一次出現該字符的索引；如果在該點之前未出現該字符，則返回 -1。
--------------------------------------------------------------------------------
indexOf
public int indexOf(String str)返回指定子字符串在此字符串中第一次出現處的索引。返回的整數是
this.startsWith(str, k)
爲 true 的最小 k 值。
參數：
str - 任意字符串。
返回：
如果字符串參數作爲一個子字符串在此對象中出現，則返回第一個這種子字符串的第一個字符的索引；如果它不作爲一個子字符串出現，則返回 -1。
--------------------------------------------------------------------------------
indexOf
public int indexOf(String str,
int fromIndex)返回指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。返回的整數是滿足下式的最小 k 值：
k >= Math.min(fromIndex, this.length()) && this.startsWith(str, k)
如果不存在這樣的 k 值，則返回 -1。
參數：
str - 要搜索的子字符串。
fromIndex - 開始搜索的索引位置。
返回：
指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。
--------------------------------------------------------------------------------
lastIndexOf
public int lastIndexOf(String str)返回指定子字符串在此字符串中最右邊出現處的索引。將最右邊的空字符串 "" 視爲出現在索引值 this.length() 處。返回的索引是
this.startsWith(str, k)
爲 true 的最大 k 值。
參數：
str - 要搜索的子字符串。
返回：
如果字符串參數作爲一個子字符串在此對象中出現一次或多次，則返回最後一個這種子字符串的第一個字符。如果它不作爲一個子字符串出現，則返回 -1。
--------------------------------------------------------------------------------
lastIndexOf
public int lastIndexOf(String str,
int fromIndex)返回指定子字符串在此字符串中最後一次出現處的索引，從指定的索引開始反向搜索。返回的整數是滿足下式的最大 k 值：
k <= Math.min(fromIndex,this.length()) && this.startsWith(str, k)
如果不存在這樣的 k 值，則返回 -1。
參數：
str - 要搜索的子字符串。
fromIndex - 開始搜索的索引位置。
返回：
指定子字符串在此字符串中最後一次出現處的索引。
--------------------------------------------------------------------------------
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 - 結束索引（不包括）。
返回：
指定的子字符串。
拋出：
IndexOutOfBoundsException - 如果 beginIndex 爲負，或 endIndex 大於此 String 對象的長度，或 beginIndex 大於 endIndex。
--------------------------------------------------------------------------------
subSequence
public CharSequence subSequence(int beginIndex,
int endIndex)返回一個新的字符序列，它是此序列的一個子序列。
此方法這種形式的調用：
str.subSequence(begin, end)與以下調用的行爲完全相同：
str.substring(begin, end)定義此方法使 String 類能夠實現 CharSequence 接口。
指定者：
接口 CharSequence 中的 subSequence
參數：
beginIndex - 起始索引（包括）。
endIndex - 結束索引（不包括）。
返回：
指定子序列。
拋出：
IndexOutOfBoundsException - 如果 beginIndex 或 endIndex 爲負，如果 endIndex 大於 length() 或 beginIndex 大於 startIndex
從以下版本開始：
1.4
--------------------------------------------------------------------------------
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 對象，它所表示的字符序列除了所有的 oldChar 都被替換爲 newChar 之外，與此 String 對象表示的字符序列相同。
示例：
"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。
--------------------------------------------------------------------------------
matches
public boolean matches(String regex)告知此字符串是否匹配給定的正則表達式。
調用此方法的 str.matches(regex) 形式與以下表達式產生的結果完全相同：
Pattern.matches(regex, str)
參數：
regex - 用來匹配此字符串的正則表達式
返回：
當且僅當此字符串匹配給定的正則表達式時，返回 true
拋出：
PatternSyntaxException - 如果正則表達式的語法無效
從以下版本開始：
1.4
另請參見：
Pattern
--------------------------------------------------------------------------------
contains
public boolean contains(CharSequence s)當且僅當此字符串包含指定的 char 值序列時，返回 true。
參數：
s - 要搜索的序列
返回：
如果此字符串包含 s，則返回 true，否則返回 false
拋出：
NullPointerException - 如果 s 爲 null
從以下版本開始：
1.5
--------------------------------------------------------------------------------
replaceFirst
public String replaceFirst(String regex,
String replacement)使用給定的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串。
調用此方法的 str.replaceFirst(regex, repl) 形式與以下表達式產生的結果完全相同：
Pattern.compile(regex).matcher(str).replaceFirst(repl)
注意，在替代字符串中使用反斜槓 (\) 和美元符號 ($) 與將其視爲字面值替代字符串所得的結果可能不同；請參閱 Matcher.replaceFirst(java.lang.String)。如有需要，可使用 Matcher.quoteReplacement(java.lang.String) 取消這些字符的特殊含義。
參數：
regex - 用來匹配此字符串的正則表達式
replacement - 用來替換第一個匹配項的字符串
返回：
所得 String
拋出：
PatternSyntaxException - 如果正則表達式的語法無效
從以下版本開始：
1.4
另請參見：
Pattern
--------------------------------------------------------------------------------
replaceAll
public String replaceAll(String regex,
String replacement)使用給定的 replacement 替換此字符串所有匹配給定的正則表達式的子字符串。
調用此方法的 str.replaceAll(regex, repl) 形式與以下表達式產生的結果完全相同：
Pattern.compile(regex).matcher(str).replaceAll(repl)
注意，在替代字符串中使用反斜槓 (\) 和美元符號 ($) 與將其視爲字面值替代字符串所得的結果可能不同；請參閱 Matcher.replaceAll。如有需要，可使用 Matcher.quoteReplacement(java.lang.String) 取消這些字符的特殊含義。
參數：
regex - 用來匹配此字符串的正則表達式
replacement - 用來替換每個匹配項的字符串
返回：
所得 String
拋出：
PatternSyntaxException - 如果正則表達式的語法無效
從以下版本開始：
1.4
另請參見：
Pattern
--------------------------------------------------------------------------------
replace
public String replace(CharSequence target,
CharSequence replacement)使用指定的字面值替換序列替換此字符串所有匹配字面值目標序列的子字符串。該替換從字符串的開頭朝末尾執行，例如，用 "b" 替換字符串 "aaa" 中的 "aa" 將生成 "ba" 而不是 "ab"。
參數：
target - 要被替換的 char 值序列
replacement - char 值的替換序列
返回：
所得 String
拋出：
NullPointerException - 如果 target 或 replacement 爲 null。
從以下版本開始：
1.5
--------------------------------------------------------------------------------
split
public String[] split(String regex,
int limit)根據匹配給定的正則表達式來拆分此字符串。
此方法返回的數組包含此字符串的子字符串，每個子字符串都由另一個匹配給定表達式的子字符串終止，或者由此字符串末尾終止。數組中的子字符串按它們在此字符串中出現的順序排列。如果表達式不匹配輸入的任何部分，那麼所得數組只具有一個元素，即此字符串。
limit 參數控制模式應用的次數，因此影響所得數組的長度。如果該限制 n 大於 0，則模式將被最多應用 n - 1 次，數組的長度將不會大於 n，而且數組的最後一項將包含所有超出最後匹配的定界符的輸入。如果 n 爲非正，那麼模式將被應用儘可能多的次數，而且數組可以是任何長度。如果 n 爲 0，那麼模式將被應用儘可能多的次數，數組可以是任何長度，並且結尾空字符串將被丟棄。
例如，字符串 "boo:and:foo" 使用這些參數可生成以下結果：
Regex Limit 結果
: 2 { "boo", "and:foo" }
: 5 { "boo", "and", "foo" }
: -2 { "boo", "and", "foo" }
o 5 { "b", "", ":and:f", "", "" }
o -2 { "b", "", ":and:f", "", "" }
o 0 { "b", "", ":and:f" }
調用此方法的 str.split(regex, n) 形式與以下表達式產生的結果完全相同：
Pattern.compile(regex).split(str, n)
參數：
regex - 定界正則表達式
limit - 結果閾值，如上所述
返回：
字符串數組，它是根據給定正則表達式的匹配拆分此字符串確定的
拋出：
PatternSyntaxException - 如果正則表達式的語法無效
從以下版本開始：
1.4
另請參見：
Pattern
--------------------------------------------------------------------------------
split
public String[] split(String regex)根據給定正則表達式的匹配拆分此字符串。
該方法的作用就像是使用給定的表達式和限制參數 0 來調用兩參數 split 方法。因此，所得數組中不包括結尾空字符串。
例如，字符串 "boo:and:foo" 使用這些表達式可生成以下結果：
Regex 結果
: { "boo", "and", "foo" }
o { "b", "", ":and:f" }
參數：
regex - 定界正則表達式
返回：
字符串數組，它是根據給定正則表達式的匹配拆分此字符串確定的
拋出：
PatternSyntaxException - 如果正則表達式的語法無效
從以下版本開始：
1.4
另請參見：
Pattern
--------------------------------------------------------------------------------
toLowerCase
public String toLowerCase(Locale locale)使用給定 Locale 的規則將此 String 中的所有字符都轉換爲小寫。大小寫映射關係基於 Character 類指定的 Unicode 標準版。由於大小寫映射關係並不總是 1:1 的字符映射關係，因此所得 String 的長度可能不同於原 String。
下表中給出了幾個小寫映射關係的示例： 語言環境的代碼 大寫字母 小寫字母 描述
tr (Turkish) \u0130 \u0069 大寫字母 I，上面有點 -> 小寫字母 i
tr (Turkish) \u0049 \u0131 大寫字母 I -> 小寫字母 i，無點
(all) French Fries french fries 將字符串中的所有字符都小寫
(all) capiotacapchi capthetacapupsil capsigma iotachi thetaupsilon sigma 將字符串中的所有字符都小寫
參數：
locale - 使用此語言環境的大小寫轉換規則
返回：
要轉換爲小寫的 String。
從以下版本開始：
1.1
另請參見：
toLowerCase(), toUpperCase(), toUpperCase(Locale)
--------------------------------------------------------------------------------
toLowerCase
public String toLowerCase()使用默認語言環境的規則將此 String 中的所有字符都轉換爲小寫。這等效於調用 toLowerCase(Locale.getDefault())。
注： 此方法與語言環境有關，如果用於應獨立於語言環境解釋的字符串，則可能生成不可預料的結果。示例有編程語言標識符、協議鍵、HTML 標記。例如，"TITLE".toLowerCase() 在 Turkish（土耳其語）語言環境中返回 "t?tle"，其中“?”是 LATIN SMALL LETTER DOTLESS I 字符。對於與語言環境有關的字符，要獲得正確的結果，請使用 toLowerCase(Locale.ENGLISH)。
返回：
要轉換爲小寫的 String。
另請參見：
toLowerCase(Locale)
--------------------------------------------------------------------------------
toUpperCase
public String toUpperCase(Locale locale)使用給定 Locale 的規則將此 String 中的所有字符都轉換爲大寫。大小寫映射關係基於 Character 類指定的 Unicode 標準版。由於大小寫映射關係並不總是 1:1 的字符映射關係，因此所得 String 的長度可能不同於原 String。
下表中給出了幾個與語言環境有關和 1:M 大小寫映射關係的一些示例。
語言環境的代碼 小寫 大寫 描述
tr (Turkish) \u0069 \u0130 小寫字母 i -> 大寫字母 I，上面有點
tr (Turkish) \u0131 \u0049 小寫字母 i，無點 -> 大寫字母 I
(all) \u00df \u0053 \u0053 小寫字母 sharp s -> 兩個字母：SS
(all) Fahrvergnügen FAHRVERGNÜN
參數：
locale - 使用此語言環境的大小寫轉換規則
返回：
要轉換爲大寫的 String。
從以下版本開始：
1.1
另請參見：
toUpperCase(), toLowerCase(), toLowerCase(Locale)
--------------------------------------------------------------------------------
toUpperCase
public String toUpperCase()使用默認語言環境的規則將此 String 中的所有字符都轉換爲大寫。此方法等效於 toUpperCase(Locale.getDefault())。
注： 此方法與語言環境有關，如果用於應獨立於語言環境解釋的字符串，則可能生成不可預料的結果。示例有編程語言標識符、協議鍵、HTML 標記。例如，"title".toUpperCase() 在 Turkish（土耳其語）語言環境中返回 "T?TLE"，其中“?”是 LATIN CAPITAL LETTER I WITH DOT ABOVE 字符。對於與語言環境有關的字符，要獲得正確的結果，請使用 toUpperCase(Locale.ENGLISH)。
返回：
要轉換爲大寫的 String。
另請參見：
toUpperCase(Locale)
--------------------------------------------------------------------------------
trim
public String trim()返回字符串的副本，忽略前導空白和尾部空白。
如果此 String 對象表示一個空字符序列，或者此 String 對象表示的字符序列的第一個和最後一個字符的代碼都大於 '\u0020'（空格字符），則返回對此 String 對象的引用。
否則，若字符串中沒有代碼大於 '\u0020' 的字符，則創建並返回一個表示空字符串的新 String 對象。
否則，假定 k 爲字符串中代碼大於 '\u0020' 的第一個字符的索引，m 爲字符串中代碼大於 '\u0020' 的最後一個字符的索引。創建一個新的 String 對象，它表示此字符串中從索引 k 處的字符開始，到索引 m 處的字符結束的子字符串，即 this.substring(k, m+1) 的結果。
此方法可用於截去字符串開頭和末尾的空白（如上所述）。
返回：
此字符串移除了前導和尾部空白的副本；如果沒有前導和尾部空白，則返回此字符串。
--------------------------------------------------------------------------------
toString
public String toString()返回此對象本身（它已經是一個字符串！）。
指定者：
接口 CharSequence 中的 toString
覆蓋：
類 Object 中的 toString
返回：
字符串本身。
--------------------------------------------------------------------------------
toCharArray
public char[] toCharArray()將此字符串轉換爲一個新的字符數組。
返回：
一個新分配的字符數組，它的長度是此字符串的長度，它的內容被初始化爲包含此字符串表示的字符序列。
--------------------------------------------------------------------------------
format
public static String format(String format,
Object... args)使用指定的格式字符串和參數返回一個格式化字符串。
始終使用 Locale.getDefault() 返回的語言環境。
參數：
format - 格式字符串
args - 格式字符串中由格式說明符引用的參數。如果還有格式說明符以外的參數，則忽略這些額外的參數。參數的數目是可變的，可以爲 0。參數的最大數目受 Java Virtual Machine Specification 所定義的 Java 數組最大維度的限制。有關 null 參數的行爲依賴於轉換。
返回：
一個格式化字符串
拋出：
IllegalFormatException - 如果格式字符串中包含非法語法、與給定的參數不兼容的格式說明符，格式字符串給定的參數不夠，或者存在其他非法條件。有關所有可能的格式化錯誤的規範，請參閱 formatter 類規範的詳細信息 一節。
NullPointerException - 如果 format 爲 null
從以下版本開始：
1.5
另請參見：
Formatter
--------------------------------------------------------------------------------
format
public static String format(Locale l,
String format,
Object... args)使用指定的語言環境、格式字符串和參數返回一個格式化字符串。
參數：
l - 格式化過程中要應用的語言環境。如果 l 爲 null，則不進行本地化。
format - 格式字符串
args - 格式字符串中由格式說明符引用的參數。如果還有格式說明符以外的參數，則忽略這些額外的參數。參數的數目是可變的，可以爲 0。參數的最大數目受 Java Virtual Machine Specification 所定義的 Java 數組最大維度的限制。有關 null 參數的行爲依賴於轉換。
返回：
一個格式化字符串
拋出：
IllegalFormatException - 如果格式字符串中包含非法語法、與給定參數不兼容的格式說明符，格式字符串給定的參數不夠，或存在其他非法條件。有關所有可能的格式化錯誤的規範，請參閱 formatter 類規範的詳細信息 一節。
NullPointerException - 如果 format 爲 null
從以下版本開始：
1.5
另請參見：
Formatter
--------------------------------------------------------------------------------
valueOf
public static String valueOf(Object obj)返回 Object 參數的字符串表示形式。
參數：
obj - 一個 Object。
返回：
如果參數爲 null，則字符串等於 "null"；否則，返回 obj.toString() 的值。
另請參見：
Object.toString()
--------------------------------------------------------------------------------
valueOf
public static String valueOf(char[] data)返回 char 數組參數的字符串表示形式。字符數組的內容已被複制，後續修改不會影響新創建的字符串。
參數：
data - char 數組。
返回：
一個新分配的字符串，它表示包含在字符數組參數中的相同字符序列。
--------------------------------------------------------------------------------
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。
--------------------------------------------------------------------------------
copyValueOf
public static String copyValueOf(char[] data,
int offset,
int count)返回指定數組中表示該字符序列的 String。
參數：
data - 字符數組。
offset - 子數組的初始偏移量。
count - 子數組的長度。
返回：
一個 String，它包含字符數組的指定子數組的字符。
--------------------------------------------------------------------------------
copyValueOf
public static String copyValueOf(char[] data)返回指定數組中表示該字符序列的 String。
參數：
data - 字符數組。
返回：
一個 String，它包含字符數組的字符。
--------------------------------------------------------------------------------
valueOf
public static String valueOf(boolean b)返回 boolean 參數的字符串表示形式。
參數：
b - 一個 boolean。
返回：
如果參數爲 true，則返回一個等於 "true" 的字符串；否則，返回一個等於 "false" 的字符串。
--------------------------------------------------------------------------------
valueOf
public static String valueOf(char c)返回 char 參數的字符串表示形式。
參數：
c - 一個 char。
返回：
一個長度爲 1 的字符串，它包含參數 c 的單個字符。
--------------------------------------------------------------------------------
valueOf
public static String valueOf(int i)返回 int 參數的字符串表示形式。
該表示形式恰好是單參數的 Integer.toString 方法返回的結果。
參數：
i - 一個 int。
返回：
int 參數的字符串表示形式。
另請參見：
Integer.toString(int, int)
--------------------------------------------------------------------------------
valueOf
public static String valueOf(long l)返回 long 參數的字符串表示形式。
該表示形式恰好是單參數的 Long.toString 方法返回的結果。
參數：
l - 一個 long。
返回：
long 參數的字符串表示形式。
另請參見：
Long.toString(long)
--------------------------------------------------------------------------------
valueOf
public static String valueOf(float f)返回 float 參數的字符串表示形式。
該表示形式恰好是單參數的 Float.toString 方法返回的結果。
參數：
f - 一個 float。
返回：
float 參數的字符串表示形式。
另請參見：
Float.toString(float)
--------------------------------------------------------------------------------
valueOf
public static String valueOf(double d)返回 double 參數的字符串表示形式。
該表示形式恰好是單參數的 Double.toString 方法返回的結果。
參數：
d - 一個 double。
返回：
double 參數的字符串表示形式。
另請參見：
Double.toString(double)
--------------------------------------------------------------------------------
intern
public String intern()返回字符串對象的規範化表示形式。
一個初始爲空的字符串池，它由類 String 私有地維護。
當調用 intern 方法時，如果池已經包含一個等於此 String 對象的字符串（用 equals(Object) 方法確定），則返回池中的字符串。否則，將此 String 對象添加到池中，並返回此 String 對象的引用。
它遵循以下規則：對於任意兩個字符串 s 和 t，當且僅當 s.equals(t) 爲 true 時，s.intern() == t.intern() 才爲 true。
所有字面值字符串和字符串賦值常量表達式都使用 intern 方法進行操作。字符串字面值在 Java Language Specification 的 §3.10.5 定義。
返回：
一個字符串，內容與此字符串相同，但一定取自具有唯一字符串的池。
