鸿蒙OS String

String

java.lang.Object

|—java.lang.String

public final class String
extends Object
implements 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，Java 语言规范。

除非另有说明，否则将 null 参数传递给此类中的构造函数或方法将导致抛出 NullPointerException。

String 表示 UTF-16 格式的字符串，其中补充字符由代理对表示（有关更多信息，请参见 Character 类中的 Unicode Character Representations 部分）。索引值指的是字符代码单元，因此补充字符使用字符串中的两个位置。

除了处理 Unicode 代码单元（即 char 值）的方法之外，String 类还提供了处理 Unicode 代码点（即字符）的方法。

字段摘要

构造函数摘要

方法总结

字段详细信息

CASE_INSENSITIVE_ORDER

public static final ComparatorString CASE_INSENSITIVE_ORDER

一个比较器，它按照 compareToIgnoreCase 对 String 对象进行排序。 这个比较器是可序列化的。

请注意，此比较器不考虑语言环境，并且会导致某些语言环境的排序不令人满意。 java.text 包提供了整理器以允许对区域设置敏感的排序。

构造函数详细信息

String

public String()

初始化一个新创建的 String 对象，使其表示一个空字符序列。 请注意，由于字符串是不可变的，因此不需要使用此构造函数。

String

public String(String original)

初始化一个新创建的 String 对象，使其表示与参数相同的字符序列； 换句话说，新创建的字符串是参数字符串的副本。 除非需要原始的显式副本，否则不需要使用此构造函数，因为字符串是不可变的。

参数：

String

public String(char[] value)

分配一个新的 String 以便它表示当前包含在字符数组参数中的字符序列。 字符数组的内容被复制； 随后对字符数组的修改不会影响新创建的字符串。

参数：

String

public String(char[] value, int offset, int count)

分配一个新字符串，该字符串包含来自字符数组参数的子数组的字符。 offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度。 子数组的内容被复制； 随后对字符数组的修改不会影响新创建的字符串。

参数：

Throws:

String

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

分配一个新字符串，其中包含来自 Unicode 代码点数组参数的子数组的字符。 offset 参数是子数组的第一个代码点的索引，count 参数指定子数组的长度。 子数组的内容被转换为字符； 后续修改 int 数组不会影响新创建的字符串。

参数：

Throws:

String

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

已弃用。 此方法不能正确地将字节转换为字符。 从 JDK 1.1 开始，执行此操作的首选方法是通过采用 Charset、字符集名称或使用平台默认字符集的 String 构造函数。

分配从 8 位整数值数组的子数组构造的新字符串。

offset 参数是子数组第一个字节的索引，count 参数指定子数组的长度。

子数组中的每个字节都转换为上述方法中指定的字符。

参数：

Throws:

String

@Deprecated public String(byte[] ascii, int hibyte)

已弃用。 此方法不能正确地将字节转换为字符。 从 JDK 1.1 开始，执行此操作的首选方法是通过采用 Charset、字符集名称或使用平台默认字符集的 String 构造函数。

分配一个包含由 8 位整数值数组构造的字符的新字符串。 生成的字符串中的每个字符 cin 都是从字节数组中的相应组件 b 构造的，这样：

     c == (char)(((hibyte & 0xff) << 8)
                         | (b & 0xff))

参数:

String

public String(byte[] bytes, int offset, int length, String charsetName) throws UnsupportedEncodingException

通过使用指定的字符集解码指定的字节子数组来构造一个新的字符串。 新字符串的长度是字符集的函数，因此可能不等于子数组的长度。

当给定字节在给定字符集中无效时，此构造函数的行为未指定。 当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。

参数：

Throws:

String

public String(byte[] bytes, int offset, int length, Charset charset)

通过使用指定的字符集解码指定的字节子数组来构造一个新的字符串。 新字符串的长度是字符集的函数，因此可能不等于子数组的长度。

此方法始终使用此字符集的默认替换字符串替换格式错误的输入和不可映射的字符序列。 当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。

参数：

Throws:

String

public String(byte[] bytes, String charsetName) throws UnsupportedEncodingException

通过使用指定的字符集解码指定的字节数组来构造一个新的字符串。 新字符串的长度是字符集的函数，因此可能不等于字节数组的长度。

当给定字节在给定字符集中无效时，此构造函数的行为未指定。 当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。

参数：

Throws:

String

public String(byte[] bytes, Charset charset)

通过使用指定的字符集解码指定的字节数组来构造一个新的字符串。 新字符串的长度是字符集的函数，因此可能不等于字节数组的长度。

此方法始终使用此字符集的默认替换字符串替换格式错误的输入和不可映射的字符序列。 当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。

参数：

String

public String(byte[] bytes, int offset, int length)

通过使用平台的默认字符集解码指定的字节子数组来构造一个新的字符串。 新字符串的长度是字符集的函数，因此可能不等于子数组的长度。

当给定字节在默认字符集中无效时，此构造函数的行为未指定。 当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。

参数：

Throws:

String

public String(byte[] bytes)

通过使用平台的默认字符集解码指定的字节数组来构造一个新的字符串。 新字符串的长度是字符集的函数，因此可能不等于字节数组的长度。

当给定字节在默认字符集中无效时，此构造函数的行为未指定。 当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。

参数：

String

public String(StringBuffer buffer)

分配一个新字符串，该字符串包含字符串缓冲区参数中当前包含的字符序列。 复制字符串缓冲区的内容； 字符串缓冲区的后续修改不会影响新创建的字符串。

参数：

String

public String(StringBuilder builder)

分配一个新字符串，该字符串包含字符串构建器参数中当前包含的字符序列。 复制字符串生成器的内容； 字符串生成器的后续修改不会影响新创建的字符串。

提供此构造函数是为了简化向 StringBuilder 的迁移。 通过 toString 方法从字符串生成器获取字符串可能会运行得更快，并且通常是首选。

参数：

方法详情

length

public int length()

返回此字符串的长度。 长度等于字符串中 Unicode 代码单元的数量。

指定者：

接口 CharSequence 中的长度

返回:

此对象表示的字符序列的长度。

isEmpty

public boolean isEmpty()

当且仅当 length() 为 0 时返回 true。

返回:

如果 length() 为 0，则为 true，否则为 false

charAt

public char charAt(int index)

返回指定索引处的 char 值。 索引的范围从 0 到 length() – 1。序列的第一个 char 值在索引 0 处，下一个在索引 1 处，依此类推，与数组索引一样。

如果索引指定的 char 值是代理项，则返回代理项值。

指定者：

接口 CharSequence 中的 charAt

参数：

返回:

此字符串的指定索引处的 char 值。 第一个 char 值位于索引 0 处。

Throws:

codePointAt

public int codePointAt(int index)

返回指定索引处的字符（Unicode 代码点）。 索引指的是 char 值（Unicode 代码单元），范围从 0 到 length() – 1。

如果给定索引处指定的 char 值在高代理范围内，后续索引小于此 String 的长度，并且后续索引处的 char 值在低代理范围内，则补充代码点 返回对应于这个代理对。 否则，返回给定索引处的 char 值。

参数：

返回:

索引处字符的代码点值

Throws:

codePointBefore

public int codePointBefore(int index)

返回指定索引之前的字符（Unicode 代码点）。 索引指的是 char 值（Unicode 代码单元），范围从 1 到 CharSequence#length()。

如果 (index – 1) 处的 char 值在低代理范围内，(index – 2) 不为负，并且 (index – 2) 处的 char 值在高代理范围内，则补充代码点 返回代理对的值。 如果索引 – 1 处的 char 值是未配对的低代理或高代理，则返回代理值。

参数：

返回:

给定索引之前的 Unicode 代码点值。

Throws:

codePointCount

public int codePointCount(int beginIndex, int endIndex)

返回此 String 的指定文本范围内的 Unicode 代码点数。 文本范围从指定的 beginIndex 开始并扩展到索引 endIndex – 1 处的字符。因此，文本范围的长度（以字符为单位）为 endIndex-beginIndex。 文本范围内的未配对代理项分别计为一个代码点。

参数：

返回:

指定文本范围内的 Unicode 代码点数

Throws:

offsetByCodePoints

public int offsetByCodePoints(int index, int codePointOffset)

返回此 String 中的索引，该索引从给定索引偏移 codePointOffset 代码点。 由 index 和 codePointOffset 给出的文本范围内的未配对代理分别计为一个代码点。

参数：

返回:

此字符串中的索引

Throws:

getChars

public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

将此字符串中的字符复制到目标字符数组中。

要复制的第一个字符位于索引 srcBegin； 要复制的最后一个字符位于索引 srcEnd-1 处（因此要复制的字符总数为 srcEnd-srcBegin）。 字符被复制到 dst 的子数组中，从索引 dstBegin 开始，到索引结束：

     dstBegin + (srcEnd-srcBegin) - 1 

参数:

Throws:

getBytes

@Deprecated public void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)

已弃用。 此方法不能正确地将字符转换为字节。 从 JDK 1.1 开始，执行此操作的首选方法是通过 getBytes() 方法，该方法使用平台的默认字符集。

将此字符串中的字符复制到目标字节数组中。 每个字节接收相应字符的 8 个低位。 每个字符的高八位不被复制，不以任何方式参与传输。

要复制的第一个字符位于索引 srcBegin； 要复制的最后一个字符位于索引 srcEnd-1 处。 要复制的字符总数为 srcEnd-srcBegin。 转换为字节的字符被复制到 dst 的子数组中，从索引 dstBegin 开始，到索引结束：

     dstBegin + (srcEnd-srcBegin) - 1 

参数:

Throws:

getBytes

public byte[] getBytes(String charsetName) throws UnsupportedEncodingException

使用命名字符集将此字符串编码为字节序列，并将结果存储到新的字节数组中。

未指定此字符串无法在给定字符集中编码时此方法的行为。 当需要对编码过程进行更多控制时，应使用 CharsetEncoder 类。

参数：

返回:

结果字节数组

Throws:

getBytes

public byte[] getBytes(Charset charset)

使用给定的字符集将此字符串编码为字节序列，并将结果存储到新的字节数组中。

此方法始终使用此字符集的默认替换字节数组替换格式错误的输入和不可映射的字符序列。 当需要对编码过程进行更多控制时，应使用 CharsetEncoder 类。

参数：

返回:

结果字节数组

getBytes

public byte[] getBytes()

使用平台的默认字符集将此字符串编码为字节序列，并将结果存储到新的字节数组中。

当此字符串无法以默认字符集编码时，此方法的行为未指定。 当需要对编码过程进行更多控制时，应使用 CharsetEncoder 类。

返回:

结果字节数组

equals

public boolean equals(Object anObject)

将此字符串与指定对象进行比较。 当且仅当参数不为 null 并且是表示与此对象相同的字符序列的 String 对象时，结果才为真。

覆盖：

类 Object 中的等于

参数：

返回:

如果给定对象表示与此字符串等效的字符串，则为 true，否则为 false

contentEquals

public boolean contentEquals(StringBuffer sb)

将此字符串与指定的 StringBuffer 进行比较。 当且仅当此 String 表示与指定 StringBuffer 相同的字符序列时，结果才为真。 此方法在 StringBuffer 上同步。

参数：

返回:

如果此 String 表示与指定 StringBuffer 相同的字符序列，则为 true，否则为 false

contentEquals

public boolean contentEquals(CharSequence cs)

将此字符串与指定的 CharSequence 进行比较。 当且仅当此 String 表示与指定序列相同的 char 值序列时，结果才为真。 请注意，如果 CharSequence 是 StringBuffer，则该方法会在其上同步。

参数：

返回:

如果此 String 表示与指定序列相同的 char 值序列，则为 true，否则为 false

equalsIgnoreCase

public boolean equalsIgnoreCase(String anotherString)

将此字符串与另一个字符串进行比较，忽略大小写注意事项。 如果两个字符串的长度相同，并且两个字符串中的对应字符相等，忽略大小写，则认为两个字符串相等。

如果以下至少一项为真，则两个字符 c1 和 c2 被认为是相同的忽略大小写：

• 两个字符相同（由 == 运算符比较）
• 将方法 Character.toUpperCase(char) 应用于每个字符会产生相同的结果
• 将方法 Character.toLowerCase(char) 应用于每个字符会产生相同的结果

参数:

返回:

如果参数不为 null 并且它表示忽略大小写的等效字符串，则为 true； 否则为假

compareTo

public int compareTo(String anotherString)

按字典顺序比较两个字符串。比较基于字符串中每个字符的 Unicode 值。此 String 对象表示的字符序列按字典顺序与参数字符串表示的字符序列进行比较。如果此 String 对象按字典顺序位于参数字符串之前，则结果为负整数。如果此 String 对象按字典顺序跟随参数字符串，则结果为正整数。如果字符串相等，则结果为零；当 equals(java.lang.Object) 方法返回 true 时，compareTo 返回 0。

这是字典顺序的定义。如果两个字符串不同，则它们在某个索引处具有不同的字符，该索引是两个字符串的有效索引，或者它们的长度不同，或两者兼而有之。如果它们在一个或多个索引位置具有不同的字符，则设 k 为此类索引中的最小；然后，在位置 k 处的字符具有较小值的字符串（通过使用 < 运算符确定）按字典顺序位于另一个字符串之前。在这种情况下，compareTo 返回两个字符串中位置 k 处的两个字符值的差值——即值：

 this.charAt(k)-anotherString.charAt(k) 

如果它们没有不同的索引位置，则较短的字符串按字典顺序位于较长的字符串之前。 在这种情况下， compareTo 返回字符串长度的差值——即值：

 this.length()-anotherString.length() 

指定者：

接口 ComparableString 中的 compareTo

参数：

返回:

如果参数字符串等于该字符串，则值为 0； 如果此字符串按字典顺序小于字符串参数，则值小于 0； 如果此字符串按字典顺序大于字符串参数，则值大于 0。

compareToIgnoreCase

public int compareToIgnoreCase(String str)

按字典顺序比较两个字符串，忽略大小写差异。 此方法返回一个整数，其符号是使用字符串的规范化版本调用 compareTo 的符号，其中通过对每个字符调用 Character.toLowerCase(Character.toUpperCase(character)) 消除了大小写差异。

请注意，此方法不考虑语言环境，并且会导致某些语言环境的排序不令人满意。 java.text 包提供整理器以允许对区域设置敏感的排序。

参数：

返回:

负整数、零或正整数，因为指定的字符串大于、等于或小于此字符串，忽略大小写考虑。

regionMatches

public boolean regionMatches(int toffset, String other, int ooffset, int len)

测试两个字符串区域是否相等。

此 String 对象的子字符串与参数 other 的子字符串进行比较。 如果这些子字符串表示相同的字符序列，则结果为真。 要比较的此 String 对象的子字符串从索引 tooffset 开始，长度为 len。 要比较的 other 的子字符串从索引 ooffset 开始，长度为 len。 当且仅当以下至少一项为真时，结果为假：

• toffset 为负数。
• ooffset为负。
• toffset+len 大于此 String 对象的长度。
• ooffset+len 大于另一个参数的长度。
• 有一些非负整数 k 小于 len 使得：this.charAt(toffset + k) != other.charAt(ooffset + k)

参数：

返回:

如果此字符串的指定子区域与字符串参数的指定子区域完全匹配，则为 true； 否则为false。

regionMatches

public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)

测试两个字符串区域是否相等。

此 String 对象的子字符串与参数 other 的子字符串进行比较。 如果这些子字符串表示相同的字符序列，则结果为真，当且仅当 ignoreCase 为真时才忽略大小写。 要比较的此 String 对象的子字符串从索引 tooffset 开始，长度为 len。 要比较的 other 的子字符串从索引 ooffset 开始，长度为 len。 当且仅当以下至少一项为真时，结果为假：

• toffset 为负。

• ooffset为负。

• toffset+len 大于此 String 对象的长度。

• ooffset+len 大于另一个参数的长度。

• ignoreCase 是假的，并且有一些非负整数 k 小于 len 使得：

 this.charAt(toffset+k) != other.charAt(ooffset+k) 

• ignoreCase 为真，并且有一些非负整数 k 小于 len 使得：

 Character.toLowerCase(this.charAt(toffset+k)) !=
   Character.toLowerCase(other.charAt(ooffset+k))

和:

   Character.toUpperCase(this.charAt(toffset+k)) !=
           Character.toUpperCase(other.charAt(ooffset+k))

参数:

返回:

如果此字符串的指定子区域与字符串参数的指定子区域匹配，则为 true； 否则为假。 匹配是精确还是不区分大小写取决于 ignoreCase 参数。

startsWith

public boolean startsWith(String prefix, int toffset)

测试从指定索引开始的此字符串的子字符串是否以指定前缀开头。

参数：

返回:

如果参数表示的字符序列是从索引 tooffset 开始的此对象的子字符串的前缀，则为 true； 否则为假。 如果 tooffset 为负数或大于此 String 对象的长度，则结果为 false； 否则结果与表达式的结果相同

          this.substring(toffset).startsWith(prefix)          

startsWith

public boolean startsWith(String prefix)

测试此字符串是否以指定的前缀开头。

参数：

返回:

如果参数表示的字符序列是此字符串表示的字符序列的前缀，则为 true； 否则为假。 另请注意，如果参数是空字符串或等于由 equals(java.lang.Object) 方法确定的此 String 对象，则将返回 true。

endsWith

public boolean endsWith(String suffix)

测试此字符串是否以指定的后缀结尾。

参数：

返回:

如果参数表示的字符序列是此对象表示的字符序列的后缀，则为 true； 否则为假。 请注意，如果参数是空字符串或等于由 equals(java.lang.Object) 方法确定的此 String 对象，则结果将为真。

hashCode

public int hashCode()

返回此字符串的哈希码。 String 对象的哈希码计算为

 s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 

使用 int 算术，其中 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂。 （空字符串的哈希值为零。）

覆盖：

类 Object 中的 hashCode

返回:

此对象的哈希码值。

indexOf

public int indexOf(int ch)

返回此字符串中第一次出现指定字符的索引。 如果值 ch 的字符出现在此 String 对象表示的字符序列中，则返回第一次出现的索引（以 Unicode 代码单位表示）。 对于 0 到 0xFFFF（含）范围内的 ch 值，这是 k 的最小值，使得：

 this.charAt(k) == ch 

是true。 对于 ch 的其他值，它是满足以下条件的最小值 k：

 this.codePointAt(k) == ch 

是true。 在任何一种情况下，如果该字符串中没有出现这样的字符，则返回 -1。

参数：

返回:

此对象表示的字符序列中字符第一次出现的索引，如果字符不出现，则为 -1。

indexOf

public int indexOf(int ch, int fromIndex)

返回此字符串中第一次出现指定字符的索引，从指定索引开始搜索。

如果值为 ch 的字符出现在此 String 对象所表示的字符序列中的索引不小于 fromIndex 处，则返回第一个此类出现的索引。 对于 0 到 0xFFFF（含）范围内的 ch 值，这是 k 的最小值，使得：

 (this.charAt(k) == ch) && (k >= fromIndex) 

是true。 对于 ch 的其他值，它是满足以下条件的最小值 k：

 (this.codePointAt(k) == ch) && (k >= fromIndex) 

是true。 在任何一种情况下，如果该字符串中的 fromIndex 位置或之后没有出现此类字符，则返回 -1。

fromIndex 的值没有限制。 如果它是负数，它的效果与它为零一样：可以搜索整个字符串。 如果它大于此字符串的长度，则其效果与等于此字符串的长度相同：返回 -1。

所有索引都以 char 值（Unicode 代码单元）指定。

参数：

返回:

此对象表示的字符序列中大于或等于 fromIndex 的字符第一次出现的索引，如果该字符不出现，则为 -1。

lastIndexOf

public int lastIndexOf(int ch)

返回此字符串中最后一次出现指定字符的索引。 对于 0 到 0xFFFF（含）范围内的 ch 值，返回的索引（以 Unicode 代码单位表示）是最大值 k，使得：

 this.charAt(k) == ch 

是true。 对于 ch 的其他值，它是最大值 k，使得：

 this.codePointAt(k) == ch 

是true。 在任何一种情况下，如果该字符串中没有出现这样的字符，则返回 -1。 从最后一个字符开始向后搜索字符串。

参数：

返回:

此对象表示的字符序列中最后一次出现的字符的索引，如果字符不出现，则为 -1。

lastIndexOf

public int lastIndexOf(int ch, int fromIndex)

返回此字符串中指定字符最后一次出现的索引，从指定索引开始向后搜索。 对于 0 到 0xFFFF（含）范围内的 ch 值，返回的索引是最大值 k，使得：

 (this.charAt(k) == ch) && (k <= fromIndex) 

是true。 对于 ch 的其他值，它是最大值 k，使得：

 (this.codePointAt(k) == ch) && (k <= fromIndex) 

是true。 在任何一种情况下，如果在此字符串中的位置 fromIndex 处或之前没有出现此类字符，则返回 -1。

所有索引都以 char 值（Unicode 代码单元）指定。

参数：

返回:

此对象表示的字符序列中字符的最后一次出现的索引，该索引小于或等于 fromIndex，如果该字符未出现在该点之前，则为 -1。

indexOf

public int indexOf(String str)

返回此字符串中第一次出现指定子字符串的索引。

返回的索引是最小值 k，其中：

 this.startsWith(str, k) 

如果不存在这样的 k 值，则返回 -1。

参数：

返回:

指定子字符串第一次出现的索引，如果没有出现，则为 -1。

indexOf

public int indexOf(String str, int fromIndex)

返回此字符串中第一次出现指定子字符串的索引，从指定索引开始。

返回的索引是最小值 k，其中：

 k >= fromIndex && this.startsWith(str, k) 

如果不存在这样的 k 值，则返回 -1。

参数：

返回:

指定子字符串第一次出现的索引，从指定的索引开始，如果没有出现，则为 -1。

lastIndexOf

public int lastIndexOf(String str)

返回此字符串中最后一次出现指定子字符串的索引。 空字符串“”的最后一次出现被认为出现在索引值 this.length() 处。

返回的索引是最大值 k，其中：

 this.startsWith(str, k) 

如果不存在这样的 k 值，则返回 -1。

参数：

返回:

指定子字符串最后一次出现的索引，如果没有出现，则返回 -1。

lastIndexOf

public int lastIndexOf(String str, int fromIndex)

返回此字符串中指定子字符串最后一次出现的索引，从指定索引开始向后搜索。

返回的索引是最大值 k，其中：

 k <= fromIndex && this.startsWith(str, k) 

如果不存在这样的 k 值，则返回 -1。

参数：

返回:

指定子字符串最后一次出现的索引，从指定的索引向后搜索，如果没有出现，则返回 -1。

substring

public String substring(int beginIndex)

返回作为此字符串的子字符串的字符串。 子字符串以指定索引处的字符开始并延伸到该字符串的末尾。

例子：

 "unhappy".substring(2) returns "happy"
 "Harbison".substring(3) returns "bison"
 "emptiness".substring(9) returns "" (an empty string)

参数:

返回:

指定的子字符串。

Throws:

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"

参数:

返回:

指定的子字符串。

Throws:

subSequence

public CharSequence subSequence(int beginIndex, int endIndex)

返回作为此序列子序列的字符序列。

调用表单的这个方法

 str.subSequence(begin, end)

行为方式与调用完全相同

 str.substring(begin, end)

指定者：

接口 CharSequence 中的子序列

参数：

返回:

指定的子序列。

Throws:

concat

public String concat(String str)

将指定的字符串连接到此字符串的末尾。

如果参数字符串的长度为 0，则返回此 String 对象。 否则，返回一个 String 对象，该对象表示一个字符序列，该字符序列是由该 String 对象表示的字符序列和由参数字符串表示的字符序列的串联。

例子：

 "cares".concat("s") returns "caress"
 "to".concat("get").concat("her") returns "together"

参数:

返回:

一个字符串，表示此对象的字符后跟字符串参数的字符的串联。

replace

public String replace(char oldChar, char newChar)

返回一个字符串，该字符串是用 newChar 替换此字符串中所有出现的 oldChar 所产生的。

如果此 String 对象表示的字符序列中没有出现 oldChar 字符，则返回对该 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)

参数:

返回:

通过用 newChar 替换每次出现的 oldChar 从该字符串派生的字符串。

matches

public boolean matches(String regex)

判断此字符串是否与给定的正则表达式匹配。

调用这种形式为 str.matches(regex) 的方法会产生与表达式完全相同的结果

Pattern.matches(regex, str)

参数:

返回:

当且仅当此字符串与给定的正则表达式匹配时才为真

Throws:

contains

public boolean contains(CharSequence s)

当且仅当此字符串包含指定的 char 值序列时才返回 true。

参数：

返回:

如果此字符串包含 s，则为 true，否则为 false

replaceFirst

public String replaceFirst(String regex, String replacement)

用给定的替换替换此字符串中与给定正则表达式匹配的第一个子字符串。

调用 str.replaceFirst(regex, repl) 形式的此方法会产生与表达式完全相同的结果

Pattern.compile(regex).matcher(str).replaceFirst(repl)

请注意，替换字符串中的反斜杠 () 和美元符号 ($) 可能会导致结果与将其视为文字替换字符串时的结果不同； 参见 Matcher.replaceFirst(java.lang.String)。 如果需要，使用 Matcher.quoteReplacement(java.lang.String) 来抑制这些字符的特殊含义。

参数：

返回:

结果字符串

Throws:

replaceAll

public String replaceAll(String regex, String replacement)

用给定的替换替换此字符串中与给定正则表达式匹配的每个子字符串。

调用 str.replaceAll(regex, repl) 形式的此方法会产生与表达式完全相同的结果

Pattern.compile(regex).matcher(str).replaceAll(repl)

请注意，替换字符串中的反斜杠 () 和美元符号 ($) 可能会导致结果与将其视为文字替换字符串时的结果不同； 请参阅 Matcher.replaceAll。 如果需要，使用 Matcher.quoteReplacement(java.lang.String) 来抑制这些字符的特殊含义。

参数：

返回:

结果字符串

Throws:

replace

public String replace(CharSequence target, CharSequence replacement)

用指定的文字替换序列替换此字符串中与文字目标序列匹配的每个子字符串。 替换从字符串的开头到结尾进行，例如，将字符串“aaa”中的“aa”替换为“b”将导致“ba”而不是“ab”。

参数：

返回:

结果字符串

split

public String[] split(String regex, int limit)

围绕给定正则表达式的匹配拆分此字符串。

此方法返回的数组包含此字符串的每个子字符串，这些子字符串由与给定表达式匹配的另一个子字符串终止或以字符串结尾终止。数组中的子字符串按照它们在此字符串中出现的顺序排列。如果表达式与输入的任何部分都不匹配，则结果数组只有一个元素，即这个字符串。

当此字符串的开头存在正宽度匹配时，则在结果数组的开头包含一个空的前导子字符串。但是，开头的零宽度匹配永远不会产生这样的空前导子字符串。

limit 参数控制应用模式的次数，因此会影响结果数组的长度。如果限制 n 大于零，则模式将最多应用 n – 1 次，数组的长度将不大于 n，并且数组的最后一个条目将包含最后一个匹配分隔符之外的所有输入。如果 n 为非正数，则该模式将尽可能多地应用，并且数组可以具有任意长度。如果 n 为零，则该模式将被应用尽可能多的次数，数组可以有任意长度，并且尾随的空字符串将被丢弃。

例如，字符串“boo:and:foo”使用这些参数产生以下结果：

以 str.split(regex, n) 形式调用此方法会产生与表达式相同的结果

Pattern.compile(regex).split(str, n)

参数:

返回:

通过围绕给定正则表达式的匹配拆分此字符串计算的字符串数组

Throws:

split

public String[] split(String regex)

围绕给定正则表达式的匹配拆分此字符串。

此方法的工作方式就像通过使用给定表达式和零限制参数调用双参数拆分方法一样。 因此，尾随的空字符串不包含在结果数组中。

例如，字符串“boo:and:foo”通过这些表达式产生以下结果：

参数：

返回:

通过围绕给定正则表达式的匹配拆分此字符串计算的字符串数组

Throws:

join

public static String join(CharSequence delimiter, CharSequence… elements)

返回一个由 CharSequence 元素的副本和指定分隔符的副本连接在一起的新字符串。

例如，

     String message = String.join("-", "Java", "is", "cool");
     // message returned is: "Java-is-cool"

请注意，如果元素为 null，则添加“null”。

参数：

返回:

由分隔符分隔的元素组成的新字符串

Throws:

join

public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

返回一个由 CharSequence 元素的副本和指定分隔符的副本连接在一起的新字符串。

例如，

     List<String> strings = new LinkedList<>();
     strings.add("Java");strings.add("is");
     strings.add("cool");
     String message = String.join(" ", strings);
     //message returned is: "Java is cool"

     Set<String> strings = new LinkedHashSet<>();
     strings.add("Java"); strings.add("is");
     strings.add("very"); strings.add("cool");
     String message = String.join("-", strings);
     //message returned is: "Java-is-very-cool"

请注意，如果单个元素为空，则添加“null”。

参数：

返回:

由元素参数组成的新字符串

Throws:

toLowerCase

public String toLowerCase(Locale locale)

使用给定语言环境的规则将此字符串中的所有字符转换为小写。 大小写映射基于 Character 类指定的 Unicode 标准版本。 由于大小写映射并不总是 1:1 字符映射，因此生成的字符串可能与原始字符串的长度不同。

小写映射的示例如下表所示：

参数：

返回:

字符串，转换为小写。

toLowerCase

public String toLowerCase()

使用默认语言环境的规则将此字符串中的所有字符转换为小写。 这相当于调用 toLowerCase(Locale.getDefault())。

注意：此方法对语言环境敏感，如果用于旨在独立解释语言环境的字符串，可能会产生意外结果。 示例是编程语言标识符、协议键和 HTML 标记。 例如，土耳其语言环境中的 “TITLE”.toLowerCase() 返回 “t\u0131tle”，其中 ‘\u0131’ 是 LATIN SMALL LETTER DOTLESS I 字符。 要获得不区分区域设置的字符串的正确结果，请使用 toLowerCase(Locale.ROOT)。

返回:

字符串，转换为小写。

toUpperCase

public String toUpperCase(Locale locale)

使用给定语言环境的规则将此字符串中的所有字符转换为大写。 大小写映射基于 Character 类指定的 Unicode 标准版本。 由于大小写映射并不总是 1:1 字符映射，因此生成的字符串可能与原始字符串的长度不同。

下表列出了区域敏感和 1:M 大小写映射的示例。

参数：

返回:

字符串，转换为大写。

toUpperCase

public String toUpperCase()

使用默认语言环境的规则将此字符串中的所有字符转换为大写。 此方法等效于 toUpperCase(Locale.getDefault())。

注意：此方法对语言环境敏感，如果用于旨在独立解释语言环境的字符串，可能会产生意外结果。 示例是编程语言标识符、协议键和 HTML 标记。 例如，土耳其语言环境中的 “title”.toUpperCase() 返回 “T\u0130TLE”，其中 ‘\u0130’ 是 LATIN CAPITAL LETTER I WITH DOT ABOVE 字符。 要获得不区分区域设置的字符串的正确结果，请使用 toUpperCase(Locale.ROOT)。

返回:

字符串，转换为大写。

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() 返回的语言环境。

参数：

返回:

格式化的字符串

Throws:

format

public static String format(Locale l, String format, Object… args)

返回使用指定语言环境、格式字符串和参数的格式化字符串。

参数：

返回:

格式化的字符串

Throws:

valueOf

public static String valueOf(Object obj)

返回 Object 参数的字符串表示形式。

参数：

返回:

如果参数为空，则字符串等于“null”； 否则，返回 obj.toString() 的值。

valueOf

public static String valueOf(char[] data)

返回 char 数组参数的字符串表示形式。 字符数组的内容被复制； 字符数组的后续修改不会影响返回的字符串。

参数：

返回:

一个包含字符数组字符的字符串。

valueOf

public static String valueOf(char[] data, int offset, int count)

返回 char 数组参数的特定子数组的字符串表示形式。

offset 参数是子数组第一个字符的索引。 count 参数指定子数组的长度。 子数组的内容被复制； 字符数组的后续修改不会影响返回的字符串。

参数：

返回:

一个字符串，包含字符数组的指定子数组的字符。

Throws:

copyValueOf

public static String copyValueOf(char[] data, int offset, int count)

等效于 [valueOf(char],int,int)。

参数：

返回:

一个字符串，包含字符数组的指定子数组的字符。

Throws:

copyValueOf

public static String copyValueOf(char[] data)

等效于 [valueOf(char])。

参数：

返回:

一个包含字符数组字符的字符串。

valueOf

public static String valueOf(boolean b)

返回布尔参数的字符串表示形式。

参数：

返回:

如果参数为真，则返回一个等于“true”的字符串； 否则，返回等于“false”的字符串。

valueOf

public static String valueOf(char c)

返回 char 参数的字符串表示形式。

参数：

返回:

长度为 1 的字符串，包含参数 c 作为其单个字符。

valueOf

public static String valueOf(int i)

返回 int 参数的字符串表示形式。

该表示正是一个参数的 Integer.toString 方法返回的表示。

参数：

返回:

int 参数的字符串表示形式。

valueOf

public static String valueOf(long l)

返回 long 参数的字符串表示。

该表示正是 Long.toString 方法返回的一个参数。

参数：

返回:

long 参数的字符串表示形式。

valueOf

public static String valueOf(float f)

返回 float 参数的字符串表示形式。

该表示正是一个参数的 Float.toString 方法返回的表示。

参数：

返回:

float 参数的字符串表示形式。

valueOf

public static String valueOf(double d)

返回 double 参数的字符串表示形式。

该表示正是一个参数的 Double.toString 方法返回的表示。

参数：

返回:

double 参数的字符串表示形式。

intern

public String intern()

返回字符串对象的规范表示。

一个字符串池，最初是空的，由 String 类私下维护。

当调用 intern 方法时，如果池中已经包含一个等于该 String 对象的字符串，由 equals(java.lang.Object) 方法确定，则返回池中的字符串。 否则，将此 String 对象添加到池中并返回对该 String 对象的引用。

由此可见，对于任何两个字符串 s 和 t，当且仅当 s.equals(t) 为真时，s.intern() == t.intern() 才为真。

所有文字字符串和字符串值的常量表达式都是实习的。 字符串字面量在《The Java™ Language Specification》的第 3.10.5 节中定义。

返回:

与此字符串具有相同内容的字符串，但保证来自唯一字符串池。