類 String詳細用法小結

阿新 • • 發佈：2019-01-09

public final class String

extends Objectimplements Serializable, Comparable<String>, CharSequence

String 類代表字串。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 值）的方法。

欄位摘要
一個對 `String` 物件進行排序的 Comparator，作用與 `compareToIgnoreCase` 相同。

構造方法摘要
初始化一個新建立的 `String` 物件，使其表示一個空字元序列。
`(byte[] bytes)` 通過使用平臺的預設字符集解碼指定的 byte 陣列，構造一個新的 `String`。
`(byte[] bytes, Charset charset)` 通過使用指定的 charset 解碼指定的 byte 陣列，構造一個新的 `String`。
`(byte[] ascii, int hibyte)` 已過時。該方法無法將位元組正確地轉換為字元。從 JDK 1.1 開始，完成該轉換的首選方法是使用帶有 `Charset`、字符集名稱，或使用平臺預設字符集的 `String` 構造方法。
`(byte[] bytes, int offset, int length)` 通過使用平臺的預設字符集解碼指定的 byte 子陣列，構造一個新的 `String`。
`(byte[] bytes, int offset, int length, Charset charset)` 通過使用指定的 charset 解碼指定的 byte 子陣列，構造一個新的 `String`。
`(byte[] ascii, int hibyte, int offset, int count)` 已過時。該方法無法將位元組正確地轉換為字元。從 JDK 1.1 開始，完成該轉換的首選方法是使用帶有 `Charset`、字符集名稱，或使用平臺預設字符集的 `String` 構造方法。
`(byte[] bytes, int offset, int length, String charsetName)` 通過使用指定的字符集解碼指定的 byte 子陣列，構造一個新的 `String`。
`(byte[] bytes, String charsetName)` 通過使用指定的 charset 解碼指定的 byte 陣列，構造一個新的 `String`。
`(char[] value)` 分配一個新的 `String`，使其表示字元陣列引數中當前包含的字元序列。
`(char[] value, int offset, int count)` 分配一個新的 `String`，它包含取自字元陣列引數一個子陣列的字元。
`(int[] codePoints, int offset, int count)` 分配一個新的 `String`，它包含 Unicode 程式碼點陣列引數一個子陣列的字元。
初始化一個新建立的 `String` 物件，使其表示一個與引數相同的字元序列；換句話說，新建立的字串是該引數字串的副本。
分配一個新的字串，它包含字串緩衝區引數中當前包含的字元序列。
分配一個新的字串，它包含字串生成器引數中當前包含的字元序列。

方法摘要
`char`	`(int index)` 返回指定索引處的 `char` 值。
`int`	返回指定索引處的字元（Unicode 程式碼點）。
`int`	返回指定索引之前的字元（Unicode 程式碼點）。
`int`	`(int beginIndex, int endIndex)` 返回此 `String` 的指定文字範圍中的 Unicode 程式碼點數。
`int`	按字典順序比較兩個字串。
`boolean`	當且僅當此字串包含指定的 char 值序列時，返回 true。
返回指定陣列中表示該字元序列的 String。
`(char[] data, int offset, int count)` 返回指定陣列中表示該字元序列的 String。
`boolean`	測試此字串是否以指定的字尾結束。
`boolean`	將此字串與指定的物件比較。
`boolean`	將此 `String` 與另一個 `String` 比較，不考慮大小寫。
使用指定的語言環境、格式字串和引數返回一個格式化字串。
使用指定的格式字串和引數返回一個格式化字串。
`byte[]`	使用平臺的預設字符集將此 `String` 編碼為 byte 序列，並將結果儲存到一個新的 byte 陣列中。
`byte[]`	使用給定的 charset 將此 `String` 編碼到 byte 序列，並將結果儲存到新的 byte 陣列。
`void`	`(int srcBegin, int srcEnd, byte[] dst, int dstBegin)` 已過時。該方法無法將字元正確轉換為位元組。從 JDK 1.1 起，完成該轉換的首選方法是通過 `getBytes()` 方法，該方法使用平臺的預設字符集。
`byte[]`	使用指定的字符集將此 `String` 編碼為 byte 序列，並將結果儲存到一個新的 byte 陣列中。
`void`	`(int srcBegin, int srcEnd, char[] dst, int dstBegin)` 將字元從此字串複製到目標字元陣列。
`int`	返回此字串的雜湊碼。
`int`	返回指定字元在此字串中第一次出現處的索引。
`int`	`(int ch, int fromIndex)` 返回在此字串中第一次出現指定字元處的索引，從指定的索引開始搜尋。
`int`	返回指定子字串在此字串中第一次出現處的索引。
`int`	返回指定子字串在此字串中第一次出現處的索引，從指定的索引開始。
返回字串物件的規範化表示形式。
`boolean`
`int`	返回指定字元在此字串中最後一次出現處的索引。
`int`	`(int ch, int fromIndex)` 返回指定字元在此字串中最後一次出現處的索引，從指定的索引處開始進行反向搜尋。
`int`	返回指定子字串在此字串中最右邊出現處的索引。
`int`	返回指定子字串在此字串中最後一次出現處的索引，從指定的索引開始反向搜尋。
`int`	返回此字串的長度。
`boolean`	告知此字串是否匹配給定的正則表示式。
`int`	`(int index, int codePointOffset)` 返回此 `String` 中從給定的 `index` 處偏移 `codePointOffset` 個程式碼點的索引。
`boolean`	`(boolean ignoreCase, int toffset, String other, int ooffset, int len)` 測試兩個字串區域是否相等。
`boolean`	`(int toffset, String other, int ooffset, int len)` 測試兩個字串區域是否相等。
`(char oldChar, char newChar)` 返回一個新的字串，它是通過用 `newChar` 替換此字串中出現的所有 `oldChar` 得到的。
使用給定的 replacement 替換此字串所有匹配給定的正則表示式的子字串。
使用給定的 replacement 替換此字串匹配給定的正則表示式的第一個子字串。
`split(String regex)` 根據給定正則表示式的匹配拆分此字串。
`split(String regex, int limit)` 根據匹配給定的正則表示式來拆分此字串。
`boolean`	測試此字串是否以指定的字首開始。
`boolean`	測試此字串從指定索引開始的子字串是否以指定字首開始。
`(int beginIndex, int endIndex)` 返回一個新的字元序列，它是此序列的一個子序列。
`(int beginIndex)` 返回一個新的字串，它是此字串的一個子字串。
`(int beginIndex, int endIndex)` 返回一個新字串，它是此字串的一個子字串。
`char[]`	將此字串轉換為一個新的字元陣列。
使用預設語言環境的規則將此 `String` 中的所有字元都轉換為小寫。
使用給定 `Locale` 的規則將此 `String` 中的所有字元都轉換為小寫。
返回此物件本身（它已經是一個字串！）。
使用預設語言環境的規則將此 `String` 中的所有字元都轉換為大寫。
使用給定 `Locale` 的規則將此 `String` 中的所有字元都轉換為大寫。
`trim()` 返回字串的副本，忽略前導空白和尾部空白。
返回 `boolean` 引數的字串表示形式。
返回 `char` 引數的字串表示形式。
`(char[] data)` 返回 `char` 陣列引數的字串表示形式。
`(char[] data, int offset, int count)` 返回 `char` 陣列引數的特定子陣列的字串表示形式。
返回 `double` 引數的字串表示形式。
返回 `float` 引數的字串表示形式。
返回 `int` 引數的字串表示形式。
返回 `long` 引數的字串表示形式。
返回 `Object` 引數的字串表示形式。

欄位詳細資訊

CASE_INSENSITIVE_ORDER

public static final Comparator<String> CASE_INSENSITIVE_ORDER

一個對 String 物件進行排序的 Comparator，作用與 compareToIgnoreCase 相同。此比較器是可序列化的。

注意，Comparator 不考慮語言環境，因此可能導致在某些語言環境中的排序效果不理想。java.text 包提供 Collator 完成與語言環境有關的排序。

構造方法詳細資訊

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 - 長度。
丟擲：

String

public String(int[] codePoints,
              int offset,
              int count)

分配一個新的 String，它包含 Unicode 程式碼點陣列引數一個子陣列的字元。offset 引數是該子陣列第一個程式碼點的索引，count 引數指定子陣列的長度。將該子陣列的內容轉換為 char；後續對 int 陣列的修改不會影響新建立的字串。

引數：: codePoints - 作為 Unicode 程式碼點的源的陣列。; offset - 初始偏移量。; count - 長度。
丟擲：: - 如果 offset 和 count 引數索引字元超出 codePoints 陣列的範圍。
從以下版本開始：: 1.5

String

public String(byte[] ascii,
                         int hibyte,
                         int offset,
                         int count)

String

public String(byte[] ascii,
                         int hibyte)

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 的名稱
丟擲：
從以下版本開始：: 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
丟擲：
從以下版本開始：: 1.6

String

通過使用指定的 charset 解碼指定的 byte 陣列，構造一個新的 String。新 String 的長度是字符集的函式，因此可能不等於 byte 陣列的長度。

當給定 byte 在給定字符集中無效的情況下，此構造方法的行為沒有指定。如果需要對解碼過程進行更多控制，則應該使用 CharsetDecoder 類。

引數：: bytes - 要解碼為字元的 byte; charsetName - 受支援的 charset 的名稱
丟擲：
從以下版本開始：: 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 數
丟擲：
從以下版本開始：: 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 程式碼單元的數量。

返回：: 此物件表示的字元序列的長度。

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 值是代理項，則返回代理項值。

引數：: index - char 值的索引。
返回：: 此字串指定索引處的 char 值。第一個 char 值位於索引 0 處。
丟擲：

codePointAt

public int codePointAt(int index)

返回指定索引處的字元（Unicode 程式碼點）。索引引用 char 值（Unicode 程式碼單元），其範圍從

到 length() - 1。

如果給定索引指定的 char 值屬於高代理項範圍，則後續索引小於此 String 的長度；如果後續索引處的 char 值屬於低代理項範圍，則返回該代理項對相應的增補程式碼點。否則，返回給定索引處的 char 值。

引數：: index - char 值的索引
返回：: index 處字元的程式碼點值
丟擲：
從以下版本開始：: 1.5

codePointBefore

public int codePointBefore(int index)

返回指定索引之前的字元（Unicode 程式碼點）。索引引用 char 值（Unicode 程式碼單元），其範圍從

到 length。

如果 (index - 1) 處的 char 值屬於低代理項範圍，則 (index - 2) 為非負；如果 (index - 2) 處的 char 值屬於高低理項範圍，則返回該代理項對的增補程式碼點值。如果 index - 1 處的 char 值是未配對的低（高）代理項，則返回代理項值。

引數：: index - 應返回的程式碼點之後的索引
返回：: 給定索引前面的 Unicode 程式碼點。
丟擲：
從以下版本開始：: 1.5

codePointCount

public int codePointCount(int beginIndex,
                          int endIndex)

返回此 String 的指定文字範圍中的 Unicode 程式碼點數。文字範圍始於指定的 beginIndex，一直到索引 endIndex - 1 處的 char。因此，該文字範圍的長度（用 char 表示）是 endIndex-beginIndex。該文字範圍內每個未配對的代理項計為一個程式碼點。

引數：: beginIndex - 文字範圍的第一個 char 的索引。; endIndex - 文字範圍的最後一個 char 之後的索引。
返回：: 指定文字範圍中 Unicode 程式碼點的數量
丟擲：: - 如果 beginIndex 為負，或 endIndex 大於此 String 的長度，或 beginIndex 大於 endIndex。
從以下版本開始：: 1.5

offsetByCodePoints

public int offsetByCodePoints(int index,
                              int codePointOffset)

返回此 String 中從給定的 index 處偏移 codePointOffset 個程式碼點的索引。文字範圍內由 index 和 codePointOffset 給定的未配對代理項各計為一個程式碼點。

引數：: index - 要偏移的索引; codePointOffset - 程式碼點中的偏移量
返回：: String 的索引
丟擲：: - 如果 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 - 目標陣列中的起始偏移量。

丟擲：

- 如果下列任何一項為 true：

srcBegin 為負。
srcBegin 大於 srcEnd
srcEnd 大於此字串的長度
dstBegin 為負
dstBegin+(srcEnd-srcBegin) 大於 dst.length

getBytes

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 - 目標陣列中的起始偏移量

丟擲：

- 如果下列任何一項為 true：

srcBegin 為負
srcBegin 大於 srcEnd
srcEnd 大於此 String 的長度
dstBegin 為負
dstBegin+(srcEnd-srcBegin) 大於 dst.length

getBytes

使用指定的字符集將此 String 編碼為 byte 序列，並將結果儲存到一個新的 byte 陣列中。

當此字串不能使用給定的字符集編碼時，此方法的行為沒有指定。如果需要對編碼過程進行更多控制，則應該使用 CharsetEncoder 類。

引數：: charsetName - 受支援的 charset 名稱
返回：: 所得 byte 陣列
丟擲：
從以下版本開始：: 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。

引數：: anObject - 與此 String 進行比較的物件。
返回：: 如果給定物件表示的 String 與此 String 相等，則返回 true；否則返回 false。
另請參見：

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 這兩個字元相同。

引數：: anotherString - 與此 String 進行比較的 String。
返回：: 如果引數不為 null，且這兩個 String 相等（忽略大小寫），則返回 true；否則返回 false。
另請參見：

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()

引數：: 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
另請參見：

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。）

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 的字元的索引；如果未出現該字

類 String詳細用法小結

CASE_INSENSITIVE_ORDER

String

String

String

String

String

String

String

String

String

String

String

String

String

String

String

length

isEmpty

charAt

codePointAt

codePointBefore

codePointCount

offsetByCodePoints

getChars

getBytes

getBytes

getBytes

getBytes

equals

contentEquals

contentEquals

equalsIgnoreCase

compareTo

compareToIgnoreCase

regionMatches

regionMatches

startsWith

startsWith

endsWith

hashCode

indexOf

indexOf

相關推薦