- 所有已实现的接口:
Serializable
,CharSequence
,Comparable<String>
,Constable
,ConstantDesc
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 语言为字符串连接运算符 (+) 以及将其他对象转换为字符串提供特殊支持。有关字符串连接和转换的其他信息,请参阅Java 语言规范.
除非另有说明,否则将 null
参数传递给此类中的构造函数或方法将导致抛出 NullPointerException
。
String
表示 UTF-16 格式的字符串,其中 supplementary characters 由 surrogate pairs 表示(有关详细信息,请参阅 Character
类中的 Unicode 字符表示 部分)。索引值引用 char
代码单元,因此增补字符使用 String
中的两个位置。
String
类除了提供处理 Unicode 代码单元(即 char
值)的方法外,还提供处理 Unicode 代码点(即字符)的方法。
除非另有说明,否则比较字符串的方法不考虑locale。 Collator
类提供了用于更细粒度、区域设置敏感的字符串比较的方法。
- 实现注意事项:
-
字符串连接运算符的实现由 Java 编译器自行决定,只要编译器最终符合Java 语言规范.例如,
javac
编译器可能会根据 JDK 版本使用StringBuffer
、StringBuilder
或java.lang.invoke.StringConcatFactory
来实现运算符。字符串转换的实现一般是通过方法toString
,由Object
定义,Java中所有类都继承。 - 看Java 语言规范:
-
15.18.1 字符串连接运算符 +
- 自从:
- 1.0
- 参见:
-
字段摘要
字段 -
构造方法总结
构造方法构造方法描述String()
初始化新创建的String
对象,使其代表空字符序列。String
(byte[] bytes) 通过使用default charset
解码指定的字节数组来构造一个新的String
。String
(byte[] ascii, int hibyte) 已弃用。此方法不能正确地将字节转换为字符。String
(byte[] bytes, int offset, int length) 通过使用default charset
解码指定的字节子数组来构造一个新的String
。String
(byte[] ascii, int hibyte, int offset, int count) 已弃用。此方法不能正确地将字节转换为字符。通过使用指定的字符集解码指定的字节子数组来构造一个新的String
。通过使用指定的 charset 解码指定的字节子数组来构造一个新的String
。通过使用指定的 charset 解码指定的字节数组来构造一个新的String
。通过使用指定的 charset 解码指定的字节数组来构造一个新的String
。String
(char[] value) 分配一个新的String
以便它表示字符数组参数中当前包含的字符序列。String
(char[] value, int offset, int count) 分配一个新的String
,其中包含字符数组参数子数组中的字符。String
(int[] codePoints, int offset, int count) 分配一个新的String
,其中包含来自 Unicode代码点 数组参数的子数组的字符。初始化一个新创建的String
对象,使其代表与参数相同的字符序列;换句话说,新创建的字符串是参数字符串的副本。String
(StringBuffer buffer) 分配一个新字符串,其中包含当前包含在字符串缓冲区参数中的字符序列。String
(StringBuilder builder) 分配一个新字符串,其中包含当前包含在字符串生成器参数中的字符序列。 -
方法总结
修饰符和类型方法描述char
charAt
(int index) 返回指定索引处的char
值。chars()
返回一个int
流,对该序列的char
值进行零扩展。int
codePointAt
(int index) 返回指定索引处的字符(Unicode 代码点)。int
codePointBefore
(int index) 返回指定索引之前的字符(Unicode 代码点)。int
codePointCount
(int beginIndex, int endIndex) 返回此String
的指定文本范围内的 Unicode 代码点数。返回此序列中的代码点值流。int
按字典顺序比较两个字符串。int
按字典顺序比较两个字符串,忽略大小写差异。将指定的字符串连接到此字符串的末尾。boolean
当且仅当此字符串包含指定的 char 值序列时才返回 true。boolean
将此字符串与指定的CharSequence
进行比较。boolean
将此字符串与指定的StringBuffer
进行比较。static String
copyValueOf
(char[] data) 相当于valueOf(char[])
。static String
copyValueOf
(char[] data, int offset, int count) 返回一个Optional
,其中包含此实例的标称描述符,即实例本身。boolean
测试此字符串是否以指定的后缀结尾。boolean
将此字符串与指定对象进行比较。boolean
equalsIgnoreCase
(String anotherString) 将此String
与另一个String
进行比较,忽略大小写注意事项。static String
使用指定的格式字符串和参数返回格式化字符串。static String
使用指定的locale、格式字符串和参数返回格式化字符串。使用此字符串作为格式字符串和提供的参数的格式。byte[]
getBytes()
使用default charset
将此String
编码为字节序列,并将结果存储到新的字节数组中。void
getBytes
(int srcBegin, int srcEnd, byte[] dst, int dstBegin) 已弃用。此方法不能正确地将字符转换为字节。byte[]
使用指定的字符集将此String
编码为字节序列,并将结果存储到新的字节数组中。byte[]
使用给定的 charset 将此String
编码为字节序列,并将结果存储到新的字节数组中。void
getChars
(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将此字符串中的字符复制到目标字符数组中。int
hashCode()
返回此字符串的哈希码。indent
(int n) 根据n
的值调整此字符串每行的缩进,并规范化行终止字符。int
indexOf
(int ch) 返回指定字符在此字符串中第一次出现的索引。int
indexOf
(int ch, int fromIndex) 返回指定字符在此字符串中第一次出现的索引,从指定索引处开始搜索。int
返回指定子字符串在该字符串中第一次出现的索引。int
从指定索引开始,返回第一次出现的指定子字符串在此字符串中的索引。intern()
返回字符串对象的规范表示。boolean
isBlank()
boolean
isEmpty()
static String
join
(CharSequence delimiter, CharSequence... elements) 返回由CharSequence elements
的副本与指定的delimiter
的副本连接在一起的新字符串。static String
join
(CharSequence delimiter, Iterable<? extends CharSequence> elements) 返回一个新的String
由CharSequence elements
的副本和指定的delimiter
的副本组成。int
lastIndexOf
(int ch) 返回最后一次出现的指定字符在此字符串中的索引。int
lastIndexOf
(int ch, int fromIndex) 返回最后一次出现的指定字符在此字符串中的索引,从指定索引开始向后搜索。int
lastIndexOf
(String str) 返回最后一次出现的指定子字符串在此字符串中的索引。int
lastIndexOf
(String str, int fromIndex) 返回最后一次出现的指定子字符串在此字符串中的索引,从指定索引开始向后搜索。int
length()
返回此字符串的长度。lines()
返回从此字符串中提取的行流,由行终止符分隔。boolean
判断此字符串是否与给定的 正则表达式 匹配。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) 测试两个字符串区域是否相等。repeat
(int count) 返回一个字符串,其值是此字符串重复count
次的串联。replace
(char oldChar, char newChar) 返回将此字符串中所有出现的oldChar
替换为newChar
的字符串。replace
(CharSequence target, CharSequence replacement) 用指定的文字替换序列替换此字符串中与文字目标序列匹配的每个子字符串。replaceAll
(String regex, String replacement) 用给定的替换替换此字符串中与给定的 正则表达式 匹配的每个子字符串。replaceFirst
(String regex, String replacement) 用给定的替换替换此字符串中与给定的 正则表达式 匹配的第一个子字符串。将此实例解析为ConstantDesc
,其结果是实例本身。String[]
围绕给定 正则表达式 的匹配项拆分此字符串。String[]
围绕给定 正则表达式 的匹配项拆分此字符串。boolean
startsWith
(String prefix) 测试此字符串是否以指定前缀开头。boolean
startsWith
(String prefix, int toffset) 测试从指定索引开始的此字符串的子字符串是否以指定前缀开头。strip()
返回一个字符串,其值为该字符串,删除所有前导和尾随 空白。返回一个字符串,其值为该字符串,并从每行的开头和结尾删除附带的 空白。返回一个字符串,其值是这个字符串,所有前导 空白 都被删除。返回值为该字符串的字符串,删除所有尾随 空白。subSequence
(int beginIndex, int endIndex) 返回作为此序列子序列的字符序列。substring
(int beginIndex) 返回一个字符串,该字符串是此字符串的子字符串。substring
(int beginIndex, int endIndex) 返回一个字符串,该字符串是此字符串的子字符串。char[]
将此字符串转换为新的字符数组。使用默认locale的规则将此String
中的所有字符转换为小写。toLowerCase
(Locale locale) 使用给定Locale
的规则将此String
中的所有字符转换为小写。toString()
这个对象(已经是一个字符串!)使用默认locale的规则将此String
中的所有字符转换为大写。toUpperCase
(Locale locale) 使用给定Locale
的规则将此String
中的所有字符转换为大写。<R> R
此方法允许将函数应用到this
字符串。返回一个字符串,其值为该字符串,转义序列被翻译成字符串文字。trim()
返回一个字符串,其值为该字符串,删除了所有前导和尾随空格,其中空格定义为代码点小于或等于'U+0020'
(空格字符)的任何字符。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
返回Object
参数的字符串表示形式。
-
字段详细信息
-
CASE_INSENSITIVE_ORDER
按compareToIgnoreCase
排序String
对象的比较器。这个比较器是可序列化的。请注意,此比较器确实not考虑了locale,并且会导致某些locale的排序不令人满意。
Collator
类提供区域设置敏感的比较。- 自从:
- 1.2
- 参见:
-
-
构造方法详细信息
-
String
public String()初始化新创建的String
对象,使其代表空字符序列。请注意,使用此构造函数是不必要的,因为字符串是不可变的。 -
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
为负,或者offset
大于value.length - count
-
String
public String(int[] codePoints, int offset, int count) 分配一个新的String
,其中包含来自 Unicode代码点 数组参数的子数组的字符。offset
参数是子数组第一个代码点的索引,count
参数指定子数组的长度。子数组的内容被转换为char
s;int
数组的后续修改不会影响新创建的字符串。- 参数:
codePoints
- 作为 Unicode 代码点来源的数组offset
- 初始偏移量count
- 长度- 抛出:
IllegalArgumentException
- 如果在codePoints
中发现任何无效的 Unicode 代码点IndexOutOfBoundsException
- 如果offset
为负,count
为负,或者offset
大于codePoints.length - count
- 自从:
- 1.5
-
String
已弃用。分配一个由 8 位整数值数组的子数组构造的新String
。offset
参数是子数组第一个字节的索引,count
参数指定子数组的长度。子数组中的每个
byte
都转换为String(byte[],int)
构造函数中指定的char
。- 参数:
ascii
- 要转换为字符的字节hibyte
- 每个 16 位 Unicode 代码单元的前 8 位offset
- 初始偏移量count
- 长度- 抛出:
IndexOutOfBoundsException
- 如果offset
为负,count
为负,或者offset
大于ascii.length - count
- 参见:
-
String
已弃用。分配一个新的String
包含由 8 位整数值数组构造的字符。每个角色c结果字符串中的是从相应的组件构造的b在字节数组中这样:c == (char)(((hibyte & 0xff) << 8) | (b & 0xff))
- 参数:
ascii
- 要转换为字符的字节hibyte
- 每个 16 位 Unicode 代码单元的前 8 位- 参见:
-
String
public String(byte[] bytes, int offset, int length, String charsetName) throws UnsupportedEncodingException 通过使用指定的字符集解码指定的字节子数组来构造一个新的String
。新String
的长度是字符集的函数,因此可能不等于子数组的长度。当给定字节在给定字符集中无效时,此构造函数的行为未指定。当需要对解码过程进行更多控制时,应使用
CharsetDecoder
类。- 参数:
bytes
- 要解码为字符的字节offset
- 要解码的第一个字节的索引length
- 要解码的字节数charsetName
- 支持的名称 charset- 抛出:
UnsupportedEncodingException
- 如果不支持指定的字符集IndexOutOfBoundsException
- 如果offset
为负,length
为负,或者offset
大于bytes.length - length
- 自从:
- 1.1
-
String
通过使用指定的 charset 解码指定的字节子数组来构造一个新的String
。新String
的长度是字符集的函数,因此可能不等于子数组的长度。此方法始终用此字符集的默认替换字符串替换格式错误的输入和不可映射的字符序列。当需要对解码过程进行更多控制时,应使用
CharsetDecoder
类。- 参数:
bytes
- 要解码为字符的字节offset
- 要解码的第一个字节的索引length
- 要解码的字节数charset
- 用于解码bytes
的 charset- 抛出:
IndexOutOfBoundsException
- 如果offset
为负,length
为负,或者offset
大于bytes.length - length
- 自从:
- 1.6
-
String
通过使用指定的 charset 解码指定的字节数组来构造一个新的String
。新String
的长度是字符集的函数,因此可能不等于字节数组的长度。当给定字节在给定字符集中无效时,此构造函数的行为未指定。当需要对解码过程进行更多控制时,应使用
CharsetDecoder
类。- 参数:
bytes
- 要解码为字符的字节charsetName
- 支持的名称 charset- 抛出:
UnsupportedEncodingException
- 如果不支持指定的字符集- 自从:
- 1.1
-
String
通过使用指定的 charset 解码指定的字节数组来构造一个新的String
。新String
的长度是字符集的函数,因此可能不等于字节数组的长度。此方法始终用此字符集的默认替换字符串替换格式错误的输入和不可映射的字符序列。当需要对解码过程进行更多控制时,应使用
CharsetDecoder
类。- 参数:
bytes
- 要解码为字符的字节charset
- 用于解码bytes
的 charset- 自从:
- 1.6
-
String
public String(byte[] bytes, int offset, int length) 通过使用default charset
解码指定的字节子数组来构造一个新的String
。新String
的长度是字符集的函数,因此可能不等于子数组的长度。当给定字节在默认字符集中无效时,此构造函数的行为未指定。当需要对解码过程进行更多控制时,应使用
CharsetDecoder
类。- 参数:
bytes
- 要解码为字符的字节offset
- 要解码的第一个字节的索引length
- 要解码的字节数- 抛出:
IndexOutOfBoundsException
- 如果offset
为负,length
为负,或者offset
大于bytes.length - length
- 自从:
- 1.1
-
String
public String(byte[] bytes) 通过使用default charset
解码指定的字节数组来构造一个新的String
。新String
的长度是字符集的函数,因此可能不等于字节数组的长度。当给定字节在默认字符集中无效时,此构造函数的行为未指定。当需要对解码过程进行更多控制时,应使用
CharsetDecoder
类。- 参数:
bytes
- 要解码为字符的字节- 自从:
- 1.1
-
String
分配一个新字符串,其中包含当前包含在字符串缓冲区参数中的字符序列。复制字符串缓冲区的内容;字符串缓冲区的后续修改不会影响新创建的字符串。- 参数:
buffer
- 一个StringBuffer
-
String
分配一个新字符串,其中包含当前包含在字符串生成器参数中的字符序列。复制字符串生成器的内容;字符串生成器的后续修改不会影响新创建的字符串。提供此构造函数是为了简化向
StringBuilder
的迁移。通过toString
方法从字符串生成器获取字符串可能运行得更快,通常是首选。- 参数:
builder
- 一个StringBuilder
- 自从:
- 1.5
-
-
方法详情
-
length
public int length()返回此字符串的长度。长度等于字符串中Unicode 编码单元的个数。- 指定者:
length
在接口CharSequence
中- 返回:
- 此对象表示的字符序列的长度。
-
isEmpty
public boolean isEmpty()- 指定者:
isEmpty
在接口CharSequence
中- 返回:
true
如果length()
是0
,否则false
- 自从:
- 1.6
-
charAt
public char charAt(int index) 返回指定索引处的char
值。索引范围从0
到length() - 1
。序列的第一个char
值位于索引0
,下一个位于索引1
,依此类推,对于数组索引。如果索引指定的
char
值为 代理人 ,则返回代理项值。- 指定者:
charAt
在接口CharSequence
中- 参数:
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
s 为单位)为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
- 如果以下任何一项为真:srcBegin
是否定的。srcBegin
大于srcEnd
srcEnd
大于此字符串的长度dstBegin
是否定的dstBegin+(srcEnd-srcBegin)
大于dst.length
-
getBytes
已弃用。此方法不能正确地将字符转换为字节。从 JDK 1.1 开始,首选方法是通过使用default charset
的getBytes()
方法。将此字符串中的字符复制到目标字节数组中。每个字节接收相应字符的低 8 位。每个字符的高八位不被复制,也不以任何方式参与传输。要复制的第一个字符位于索引
srcBegin
;要复制的最后一个字符位于索引srcEnd-1
处。要复制的字符总数为srcEnd-srcBegin
。转换为字节的字符被复制到dst
的子数组中,从索引dstBegin
开始到索引结束:dstBegin + (srcEnd-srcBegin) - 1
- 参数:
srcBegin
- 要复制的字符串中第一个字符的索引srcEnd
- 要复制的字符串中最后一个字符后的索引dst
- 目标数组dstBegin
- 目标数组中的起始偏移量- 抛出:
IndexOutOfBoundsException
- 如果以下任何一项为真:srcBegin
是否定的srcBegin
大于srcEnd
srcEnd
大于此字符串的长度dstBegin
是否定的dstBegin+(srcEnd-srcBegin)
大于dst.length
-
getBytes
使用指定的字符集将此String
编码为字节序列,并将结果存储到新的字节数组中。当此字符串无法在给定字符集中编码时,此方法的行为未指定。当需要对编码过程进行更多控制时,应使用
CharsetEncoder
类。- 参数:
charsetName
- 支持的名称 charset- 返回:
- 结果字节数组
- 抛出:
UnsupportedEncodingException
- 如果不支持指定的字符集- 自从:
- 1.1
-
getBytes
使用给定的 charset 将此String
编码为字节序列,并将结果存储到新的字节数组中。此方法始终用此字符集的默认替换字节数组替换格式错误的输入和不可映射的字符序列。当需要对编码过程进行更多控制时,应使用
CharsetEncoder
类。- 参数:
charset
- 用于编码String
的 Charset- 返回:
- 结果字节数组
- 自从:
- 1.6
-
getBytes
public byte[] getBytes()使用default charset
将此String
编码为字节序列,并将结果存储到新的字节数组中。当此字符串无法在默认字符集中编码时,此方法的行为未指定。当需要对编码过程进行更多控制时,应使用
CharsetEncoder
类。- 返回:
- 结果字节数组
- 自从:
- 1.1
-
equals
-
contentEquals
将此字符串与指定的StringBuffer
进行比较。当且仅当此String
表示与指定的StringBuffer
相同的字符序列时,结果为true
。此方法在StringBuffer
上同步。有关更细粒度的字符串比较,请参阅
Collator
。- 参数:
sb
- 将此String
与StringBuffer
进行比较- 返回:
true
如果此String
表示与指定的StringBuffer
相同的字符序列,则false
否则- 自从:
- 1.4
-
contentEquals
将此字符串与指定的CharSequence
进行比较。当且仅当此String
表示与指定序列相同的 char 值序列时,结果为true
。请注意,如果CharSequence
是StringBuffer
,则该方法会对其进行同步。有关更细粒度的字符串比较,请参阅
Collator
。- 参数:
cs
- 比较这个String
的序列- 返回:
true
如果此String
表示与指定序列相同的 char 值序列,false
否则- 自从:
- 1.5
-
equalsIgnoreCase
将此String
与另一个String
进行比较,忽略大小写注意事项。如果两个字符串的长度相同并且两个字符串中对应的 Unicode 代码点相等且忽略大小写,则认为这两个字符串是相等的忽略大小写。如果以下至少一项为真,则两个 Unicode 代码点被视为相同的忽略大小写:
- 这两个 Unicode 代码点相同(通过
==
运算符进行比较) - 在每个 Unicode 代码点上调用
Character.toLowerCase(Character.toUpperCase(int))
会产生相同的结果
请注意,此方法确实 not 考虑了区域设置,并且会导致某些区域设置不令人满意的结果。
Collator
类提供区域设置敏感的比较。- 参数:
anotherString
- 用于比较此String
的String
- 返回:
true
如果参数不是null
并且它表示等效的String
忽略大小写;false
否则- 参见:
- 这两个 Unicode 代码点相同(通过
-
compareTo
按字典顺序比较两个字符串。比较基于字符串中每个字符的 Unicode 值。此String
对象表示的字符序列按字典顺序与参数字符串表示的字符序列进行比较。如果此String
对象在字典顺序上位于参数字符串之前,则结果为负整数。如果此String
对象按字典顺序跟随参数字符串,则结果为正整数。如果字符串相等,则结果为零;否则compareTo
恰好在equals(Object)
方法返回true
时返回0
。这是字典序的定义。如果两个字符串不同,那么它们要么在某个索引处具有不同的字符,该索引是两个字符串的有效索引,要么它们的长度不同,要么两者兼而有之。如果它们在一个或多个索引位置有不同的字符,让k是最小的此类索引;然后是其字符位于位置的字符串k具有较小的值,如使用
<
运算符所确定的那样,按字典顺序在另一个字符串之前。在这种情况下,compareTo
返回两个字符串中位于k
位置的两个字符值的差值——即值:this.charAt(k)-anotherString.charAt(k)
compareTo
返回字符串长度的差异——即值:this.length()-anotherString.length()
有关更细粒度的字符串比较,请参阅
Collator
。- 指定者:
compareTo
在接口Comparable<String>
中- 参数:
anotherString
- 要比较的String
。- 返回:
-
如果参数字符串等于此字符串,则值为
0
;如果此字符串按字典顺序小于字符串参数,则该值小于0
;如果此字符串按字典顺序大于字符串参数,则该值大于0
。
-
compareToIgnoreCase
按字典顺序比较两个字符串,忽略大小写差异。此方法返回一个整数,其符号是使用大小写折叠版本的字符串调用compareTo
的符号,其中通过在每个 Unicode 代码点上调用Character.toLowerCase(Character.toUpperCase(int))
消除了大小写差异。请注意,此方法确实 not 考虑了区域设置,并且会导致某些区域设置的排序不令人满意。
Collator
类提供区域设置敏感的比较。- 参数:
str
- 要比较的String
。- 返回:
- 负整数、零或正整数,因为指定的字符串大于、等于或小于此字符串,忽略大小写。
- 自从:
- 1.2
- 参见:
-
regionMatches
测试两个字符串区域是否相等。此
String
对象的子字符串与参数 other 的子字符串进行比较。如果这些子字符串表示相同的字符序列,则结果为真。要比较的这个String
对象的子字符串从索引toffset
开始,长度为len
。要比较的 other 的子字符串从索引ooffset
开始,长度为len
。结果为false
当且仅当以下至少一项为真:toffset
是否定的。ooffset
是否定的。toffset+len
大于此String
对象的长度。ooffset+len
大于另一个参数的长度。- 存在某个非负整数k小于
len
这样:this.charAt(toffset +
k) != other.charAt(ooffset +
k)
请注意,此方法确实not 考虑了locale。
Collator
类提供区域设置敏感的比较。- 参数:
toffset
- 此字符串中子区域的起始偏移量。other
- 字符串参数。ooffset
- 字符串参数中子区域的起始偏移量。len
- 要比较的字符数。- 返回:
true
如果此字符串的指定子区域与字符串参数的指定子区域完全匹配;false
否则。
-
regionMatches
测试两个字符串区域是否相等。此
String
对象的子字符串与参数other
的子字符串进行比较。如果这些子字符串表示相同的 Unicode 代码点序列,则结果为true
,当且仅当ignoreCase
为真时忽略大小写。比较序列tsequence
和osequence
,其中tsequence
是调用this.substring(toffset, toffset + len).codePoints()
产生的序列,osequence
是调用other.substring(ooffset, ooffset + len).codePoints()
产生的序列。当且仅当以下所有条件都为真时,结果为true
:toffset
是非负的。ooffset
是非负的。toffset+len
小于或等于此String
对象的长度。ooffset+len
小于或等于另一个参数的长度。- 如果
ignoreCase
是false
,所有对应的 Unicode 代码点对都是相等的整数值;或者如果ignoreCase
是true
,则所有 Unicode 代码点对上的Character.toLowerCase(
Character.toUpperCase(int)
)
会产生相等的整数值。
请注意,此方法确实 not 考虑了区域设置,并且当
ignoreCase
为true
时,对于某些区域设置将导致不令人满意的结果。Collator
类提供区域设置敏感的比较。- 参数:
ignoreCase
- 如果是true
,比较字符时忽略大小写。toffset
- 此字符串中子区域的起始偏移量。other
- 字符串参数。ooffset
- 字符串参数中子区域的起始偏移量。len
- 要比较的字符数(Unicode 代码单元 - 16 位char
值)。- 返回:
true
如果此字符串的指定子区域与字符串参数的指定子区域匹配;false
否则。匹配是精确匹配还是不区分大小写取决于ignoreCase
参数。- 参见:
-
startsWith
测试从指定索引开始的此字符串的子字符串是否以指定前缀开头。- 参数:
prefix
- 前缀。toffset
- 从哪里开始查找此字符串。- 返回:
true
如果参数表示的字符序列是此对象从索引toffset
开始的子字符串的前缀;false
否则。如果toffset
为负数或大于此String
对象的长度,则结果为false
;否则结果与表达式this.substring(toffset).startsWith(prefix)
的结果相同
-
startsWith
测试此字符串是否以指定前缀开头。- 参数:
prefix
- 前缀。- 返回:
true
如果参数表示的字符序列是此字符串表示的字符序列的前缀;false
否则。另请注意,如果参数为空字符串或等于由equals(Object)
方法确定的此String
对象,则将返回true
。- 自从:
- 1.0
-
endsWith
测试此字符串是否以指定的后缀结尾。- 参数:
suffix
- 后缀。- 返回:
true
如果参数表示的字符序列是此对象表示的字符序列的后缀;false
否则。请注意,如果参数为空字符串或等于由equals(Object)
方法确定的此String
对象,则结果将为true
。
-
hashCode
public int hashCode()返回此字符串的哈希码。String
对象的哈希码计算如下s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
int
算法,其中s[i]
是i字符串的第th个字符,n
为字符串长度,^
表示求幂。 (空字符串的哈希值为零。) -
indexOf
public int indexOf(int ch) 返回指定字符在此字符串中第一次出现的索引。如果值为ch
的字符出现在此String
对象表示的字符序列中,则返回第一个此类出现的索引(以 Unicode 代码单元为单位)。对于 0 到 0xFFFF(含)范围内的ch
值,这是最小值k这样:this.charAt(k) == ch
ch
的其他值,它是最小值k这样:this.codePointAt(k) == ch
-1
。- 参数:
ch
- 一个字符(Unicode 代码点)。- 返回:
-
此对象表示的字符序列中该字符第一次出现的索引,如果该字符未出现,则为
-1
。
-
indexOf
public int indexOf(int ch, int fromIndex) 返回指定字符在此字符串中第一次出现的索引,从指定索引处开始搜索。如果值为
ch
的字符出现在此String
对象表示的字符序列中,索引不小于fromIndex
,则返回第一次出现的索引。对于 0 到 0xFFFF(含)范围内的ch
值,这是最小值k这样:(this.charAt(k) == ch)
&&
(k >= fromIndex)ch
的其他值,它是最小值k这样:(this.codePointAt(k) == ch)
&&
(k >= fromIndex)fromIndex
或之后没有出现此类字符,则返回-1
。fromIndex
的值没有限制。如果它是负数,它的效果就好像它是零一样:可以搜索整个字符串。如果它大于此字符串的长度,则其效果与等于此字符串的长度相同:返回-1
。所有索引都在
char
值(Unicode 代码单元)中指定。- 参数:
ch
- 一个字符(Unicode 代码点)。fromIndex
- 开始搜索的索引。- 返回:
-
此对象表示的大于或等于
fromIndex
的字符序列中首次出现该字符的索引,如果该字符未出现,则为-1
。
-
lastIndexOf
public int lastIndexOf(int ch) 返回最后一次出现的指定字符在此字符串中的索引。对于ch
在0到0xFFFF(含)范围内的取值,返回的索引(以Unicode码为单位)为最大值k这样:this.charAt(k) == ch
ch
的其他值,它是最大值k这样:this.codePointAt(k) == ch
-1
。String
从最后一个字符开始向后搜索。- 参数:
ch
- 一个字符(Unicode 代码点)。- 返回:
-
此对象表示的字符序列中最后一次出现该字符的索引,如果该字符未出现,则为
-1
。
-
lastIndexOf
public int lastIndexOf(int ch, int fromIndex) 返回最后一次出现的指定字符在此字符串中的索引,从指定索引开始向后搜索。对于ch
在0到0xFFFF(含)范围内的值,返回的索引是最大值k这样:(this.charAt(k) == ch)
&&
(k <= fromIndex)ch
的其他值,它是最大值k这样:(this.codePointAt(k) == ch)
&&
(k <= fromIndex)fromIndex
处或之前没有出现此类字符,则返回-1
。所有索引都在
char
值(Unicode 代码单元)中指定。- 参数:
ch
- 一个字符(Unicode 代码点)。fromIndex
- 开始搜索的索引。fromIndex
的值没有限制。如果它大于或等于该字符串的长度,则其效果与等于该字符串的长度小一相同:可以搜索整个字符串。如果它是负数,它的效果就好像它是 -1 一样:返回 -1。- 返回:
-
此对象表示的字符序列中最后一次出现的字符的索引小于或等于
fromIndex
,或者-1
如果该字符未在此点之前出现。
-
indexOf
返回指定子字符串在该字符串中第一次出现的索引。返回的索引是最小值
k
,其中:
如果this.startsWith(str, k)
k
的值不存在,则返回-1
。- 参数:
str
- 要搜索的子字符串。- 返回:
-
指定子字符串第一次出现的索引,如果没有出现则为
-1
。
-
indexOf
从指定索引开始,返回第一次出现的指定子字符串在此字符串中的索引。返回的索引是最小值
k
,其中:
如果k >= Math.min(fromIndex, this.length()) && this.startsWith(str, k)
k
的值不存在,则返回-1
。- 参数:
str
- 要搜索的子字符串。fromIndex
- 开始搜索的索引。- 返回:
-
指定子字符串第一次出现的索引,从指定索引开始,如果没有这样的出现,则为
-1
。
-
lastIndexOf
返回最后一次出现的指定子字符串在此字符串中的索引。空字符串 "" 的最后一次出现被认为出现在索引值this.length()
处。返回的索引是最大值
k
,其中:
如果this.startsWith(str, k)
k
的值不存在,则返回-1
。- 参数:
str
- 要搜索的子字符串。- 返回:
-
指定子字符串最后一次出现的索引,如果不存在则为
-1
。
-
lastIndexOf
返回最后一次出现的指定子字符串在此字符串中的索引,从指定索引开始向后搜索。返回的索引是最大值
k
,其中:
如果k <= Math.min(fromIndex, this.length()) && this.startsWith(str, k)
k
的值不存在,则返回-1
。- 参数:
str
- 要搜索的子字符串。fromIndex
- 开始搜索的索引。- 返回:
-
指定子字符串最后一次出现的索引,从指定索引向后搜索,如果没有这样的出现,则返回
-1
。
-
substring
返回一个字符串,该字符串是此字符串的子字符串。子字符串以指定索引处的字符开始,并延伸到该字符串的末尾。示例:
"unhappy".substring(2) returns "happy" "Harbison".substring(3) returns "bison" "emptiness".substring(9) returns "" (an empty string)
- 参数:
beginIndex
- 开始索引,包括在内。- 返回:
- 指定的子字符串。
- 抛出:
IndexOutOfBoundsException
- 如果beginIndex
为负数或大于此String
对象的长度。
-
substring
返回一个字符串,该字符串是此字符串的子字符串。子字符串从指定的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
返回作为此序列子序列的字符序列。调用此表单方法
str.subSequence(begin, end)
str.substring(begin, end)
- 指定者:
subSequence
在接口CharSequence
中- API 注意:
-
定义此方法以便
String
类可以实现CharSequence
接口。 - 参数:
beginIndex
- 开始索引,包括在内。endIndex
- 结束索引,独占。- 返回:
- 指定的子序列。
- 抛出:
IndexOutOfBoundsException
- 如果beginIndex
或endIndex
为负,如果endIndex
大于length()
,或者如果beginIndex
大于endIndex
- 自从:
- 1.4
-
concat
将指定的字符串连接到此字符串的末尾。如果参数字符串的长度为
0
,则返回此String
对象。否则,将返回一个String
对象,该对象表示一个字符序列,该字符序列是此String
对象表示的字符序列与参数字符串表示的字符序列的串联。示例:
"cares".concat("s") returns "caress" "to".concat("get").concat("her") returns "together"
- 参数:
str
- 连接到此String
末尾的String
。- 返回:
- 一个字符串,表示此对象的字符后跟字符串参数的字符的串联。
-
replace
返回将此字符串中所有出现的oldChar
替换为newChar
的字符串。如果字符
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
从此字符串派生的字符串。
-
matches
- 参数:
regex
- 此字符串要匹配的正则表达式- 返回:
true
当且仅当此字符串匹配给定的正则表达式- 抛出:
PatternSyntaxException
- 如果正则表达式的语法无效- 自从:
- 1.4
- 参见:
-
contains
当且仅当此字符串包含指定的 char 值序列时才返回 true。- 参数:
s
- 要搜索的序列- 返回:
-
如果此字符串包含
s
则为真,否则为假 - 自从:
- 1.5
-
replaceFirst
用给定的替换替换此字符串中与给定的 正则表达式 匹配的第一个子字符串。调用此表单方法海峡
.replaceFirst(
正则表达式,
回复)
产生与表达式完全相同的结果Pattern
.compile
(regex).matcher
(str).replaceFirst
(repl)请注意,替换字符串中的反斜杠 (
\
) 和美元符号 ($
) 可能会导致结果与将其视为文字替换字符串时的结果不同;见Matcher.replaceFirst(java.lang.String)
。如果需要,使用Matcher.quoteReplacement(java.lang.String)
来抑制这些字符的特殊含义。- 参数:
regex
- 此字符串要匹配的正则表达式replacement
- 要替换为第一个匹配项的字符串- 返回:
-
由此产生的
String
- 抛出:
PatternSyntaxException
- 如果正则表达式的语法无效- 自从:
- 1.4
- 参见:
-
replaceAll
用给定的替换替换此字符串中与给定的 正则表达式 匹配的每个子字符串。调用此表单方法海峡
.replaceAll(
正则表达式,
回复)
产生与表达式完全相同的结果Pattern
.compile
(regex).matcher
(str).replaceAll
(repl)请注意,替换字符串中的反斜杠 (
\
) 和美元符号 ($
) 可能会导致结果与将其视为文字替换字符串时的结果不同;见Matcher.replaceAll
。如果需要,使用Matcher.quoteReplacement(java.lang.String)
来抑制这些字符的特殊含义。- 参数:
regex
- 此字符串要匹配的正则表达式replacement
- 每个匹配项要替换的字符串- 返回:
-
由此产生的
String
- 抛出:
PatternSyntaxException
- 如果正则表达式的语法无效- 自从:
- 1.4
- 参见:
-
replace
用指定的文字替换序列替换此字符串中与文字目标序列匹配的每个子字符串。替换从字符串的开头进行到结尾,例如,将字符串“aaa”中的“aa”替换为“b”将得到“ba”而不是“ab”。- 参数:
target
- 要替换的 char 值序列replacement
- char 值的替换顺序- 返回:
- 结果字符串
- 自从:
- 1.5
-
split
围绕给定 正则表达式 的匹配项拆分此字符串。此方法返回的数组包含此字符串的每个子字符串,这些子字符串由与给定表达式匹配的另一个子字符串终止或由字符串末尾终止。数组中的子字符串按照它们在该字符串中出现的顺序排列。如果表达式不匹配输入的任何部分,则结果数组只有一个元素,即这个字符串。
当此字符串的开头存在正宽度匹配时,结果数组的开头将包含一个空的前导子字符串。然而,开头的零宽度匹配永远不会产生这样的空前导子字符串。
limit
参数控制应用模式的次数,因此会影响结果数组的长度。如果limit为正则最多应用该模式limit- 1 次,数组的长度将不大于limit, 并且数组的最后一个条目将包含最后一个匹配的定界符之外的所有输入。
如果limit为零则模式将被应用尽可能多的次数,数组可以有任何长度,尾随的空字符串将被丢弃。
如果limit为负则模式将被应用尽可能多的次数并且数组可以有任何长度。
例如,字符串
"boo:and:foo"
使用这些参数产生以下结果:Regex 限制 Result : 2 { "boo", "and:foo" }
5 { "boo", "and", "foo" }
-2 { "boo", "and", "foo" }
o 5 { "b", "", ":and:f", "", "" }
-2 { "b", "", ":and:f", "", "" }
0 { "b", "", ":and:f" }
调用此表单方法海峡
split(
正则表达式,
n)
产生与表达式相同的结果Pattern
.compile
(regex).split
(str, n)- 参数:
regex
- 定界正则表达式limit
- 结果阈值,如上所述- 返回:
- 通过围绕给定正则表达式的匹配拆分此字符串计算的字符串数组
- 抛出:
PatternSyntaxException
- 如果正则表达式的语法无效- 自从:
- 1.4
- 参见:
-
split
围绕给定 正则表达式 的匹配项拆分此字符串。此方法的工作方式就好像通过使用给定表达式和零限制参数调用双参数
split
方法一样。因此,结果数组中不包含尾随的空字符串。例如,字符串
"boo:and:foo"
使用这些表达式会产生以下结果:Regex Result : { "boo", "and", "foo" }
o { "b", "", ":and:f" }
- 参数:
regex
- 定界正则表达式- 返回:
- 通过围绕给定正则表达式的匹配拆分此字符串计算的字符串数组
- 抛出:
PatternSyntaxException
- 如果正则表达式的语法无效- 自从:
- 1.4
- 参见:
-
join
返回由CharSequence elements
的副本与指定的delimiter
的副本连接在一起的新字符串。例如,
请注意,如果元素为空,则添加String message = String.join("-", "Java", "is", "cool"); // message returned is: "Java-is-cool"
"null"
。- 参数:
delimiter
- 分隔每个元素的分隔符elements
- 要连接在一起的元素。- 返回:
-
一个新的
String
由elements
组成,由delimiter
分隔 - 抛出:
NullPointerException
- 如果delimiter
或elements
是null
- 自从:
- 1.8
- 参见:
-
join
返回一个新的String
由CharSequence elements
的副本和指定的delimiter
的副本组成。例如,
请注意,如果单个元素是List<String> strings = List.of("Java", "is", "cool"); String message = String.join(" ", strings); // message returned is: "Java is cool" Set<String> strings = new LinkedHashSet<>(List.of("Java", "is", "very", "cool")); String message = String.join("-", strings); // message returned is: "Java-is-very-cool"
null
,则会添加"null"
。- 参数:
delimiter
- 用于分隔生成的String
中的每个elements
的字符序列elements
- 一个Iterable
将其elements
连接在一起。- 返回:
-
由
elements
参数组成的新String
- 抛出:
NullPointerException
- 如果delimiter
或elements
是null
- 自从:
- 1.8
- 参见:
-
toLowerCase
使用给定Locale
的规则将此String
中的所有字符转换为小写。大小写映射基于Character
类指定的 Unicode 标准版本。由于大小写映射并不总是 1:1 字符映射,因此生成的String
和此String
的长度可能不同。小写映射的示例如下表所示:
locale代码 大写字母 小写 Description tr(土耳其语) \u0130 \u0069 上面带点的大写字母 I -> 小写字母 i tr(土耳其语) \u0049 \u0131 大写字母 I -> 小写字母无点 i (全部) 炸薯条 炸薯条 小写字符串中的所有字符 (全部) ΙχΘΥΣ ιχθυσ 小写字符串中的所有字符 - 参数:
locale
- 使用此locale的大小写转换规则- 返回:
String
,转换为小写。- 自从:
- 1.1
- 参见:
-
toLowerCase
使用默认locale的规则将此String
中的所有字符转换为小写。此方法等效于toLowerCase(Locale.getDefault())
。笔记:此方法对区域设置敏感,如果用于旨在独立解释区域设置的字符串,可能会产生意外结果。示例是编程语言标识符、协议密钥和 HTML 标记。例如,土耳其locale中的
"TITLE".toLowerCase()
返回"t\u0131tle"
,其中 '\u0131' 是拉丁文小写字母 DOTLESS I 字符。要获得不区分locale的字符串的正确结果,请使用toLowerCase(Locale.ROOT)
。- 返回:
String
,转换为小写。- 参见:
-
toUpperCase
使用给定Locale
的规则将此String
中的所有字符转换为大写。大小写映射基于Character
类指定的 Unicode 标准版本。由于大小写映射并不总是 1:1 字符映射,因此生成的String
和此String
的长度可能不同。下表列出了区域设置敏感和 1:M 大小写映射的示例:
locale代码 小写 大写字母 Description tr(土耳其语) \u0069 \u0130 小写字母 i -> 大写字母 I 上面有点 tr(土耳其语) \u0131 \u0049 小写字母无点 i -> 大写字母 I (全部) \u00df \u0053 \u0053 小写字母 sharp s -> 两个字母:SS (全部) Fahrvergnügen 法尔维尔根 - 参数:
locale
- 使用此locale的大小写转换规则- 返回:
String
,转换为大写。- 自从:
- 1.1
- 参见:
-
toUpperCase
使用默认locale的规则将此String
中的所有字符转换为大写。此方法等效于toUpperCase(Locale.getDefault())
。笔记:此方法对区域设置敏感,如果用于旨在独立解释区域设置的字符串,可能会产生意外结果。示例是编程语言标识符、协议密钥和 HTML 标记。例如,土耳其locale中的
"title".toUpperCase()
返回"T\u0130TLE"
,其中 '\u0130' 是拉丁文大写字母 I WITH DOT ABOVE 字符。要获得不区分locale的字符串的正确结果,请使用toUpperCase(Locale.ROOT)
。- 返回:
String
,转换为大写。- 参见:
-
trim
返回一个字符串,其值为该字符串,删除了所有前导和尾随空格,其中空格定义为代码点小于或等于'U+0020'
(空格字符)的任何字符。如果此
String
对象表示一个空字符序列,或者此String
对象表示的字符序列的第一个和最后一个字符的代码都不是空格(如上定义),则返回对此String
对象的引用。否则,如果此字符串中的所有字符都是空格(如上定义),则返回表示空字符串的
String
对象。否则,让k是代码不是空格(如上定义)的字符串中第一个字符的索引,并让m是代码不是空格(如上定义)的字符串中最后一个字符的索引。返回一个
String
对象,表示此字符串中以索引处的字符开头的子字符串k并以索引处的字符结尾m即this.substring(k, m + 1)
的结果。此方法可用于修剪字符串开头和结尾的空格(如上定义)。
- 返回:
- 一个字符串,其值是这个字符串,删除了所有前导和尾随空格,或者如果它没有前导或尾随空格,则为这个字符串。
-
strip
返回一个字符串,其值为该字符串,删除所有前导和尾随 空白。如果此
String
对象表示一个空字符串,或者如果此字符串中的所有代码点都是 空白 ,则返回一个空字符串。否则,返回此字符串的子字符串,从第一个不是 空白 的代码点开始,直到并包括最后一个不是 空白 的代码点。
此方法可用于从字符串的开头和结尾去除 空白。
- 返回:
- 一个字符串,其值为该字符串,删除了所有前导和尾随空格
- 自从:
- 11
- 参见:
-
stripLeading
返回一个字符串,其值是这个字符串,所有前导 空白 都被删除。如果此
String
对象表示一个空字符串,或者如果此字符串中的所有代码点都是 空白 ,则返回一个空字符串。否则,返回此字符串的子字符串,该子字符串从第一个不是 空白 的代码点开始,直到并包括此字符串的最后一个代码点。
此方法可用于从字符串的开头修剪 空白。
- 返回:
- 一个字符串,其值是这个字符串,删除了所有前导空格
- 自从:
- 11
- 参见:
-
stripTrailing
返回值为该字符串的字符串,删除所有尾随 空白。如果此
String
对象表示一个空字符串,或者如果此字符串中的所有字符都是 空白 ,则返回一个空字符串。否则,返回此字符串的子字符串,此字符串从该字符串的第一个代码点开始,直到并包括最后一个不是 空白 的代码点。
此方法可用于从字符串末尾修剪 空白。
- 返回:
- 一个字符串,其值为该字符串,删除了所有尾随空格
- 自从:
- 11
- 参见:
-
isBlank
public boolean isBlank()- 返回:
true
如果字符串为空或仅包含 空白 代码点,否则为false
- 自从:
- 11
- 参见:
-
lines
返回从此字符串中提取的行流,由行终止符分隔。A 行终止符是以下之一:换行符
"\n"
(U+000A)、回车符"\r"
(U+000D),或回车后紧跟换行符"\r\n"
(U+000D U+000A)。A 线是零个或多个字符后跟行终止符的序列,或者是一个或多个字符后跟字符串结尾的序列。一行不包括行终止符。
此方法返回的流包含此字符串中按出现顺序排列的行。
- API 注意:
- 这个定义线意味着空字符串有零行,并且在字符串末尾的行终止符后面没有空行。
- 实现注意事项:
- 通过延迟提供元素和更快地搜索新行终止符,此方法提供了比 split("\R") 更好的性能。
- 返回:
- 从此字符串中提取的行流
- 自从:
- 11
-
indent
根据n
的值调整此字符串每行的缩进,并规范化行终止字符。该字符串在概念上使用
lines()
分成几行。然后按如下所述调整每一行,然后添加换行符"\n"
(U+000A)。然后将生成的行连接起来并返回。If
n > 0
thenn
spaces (U+0020) is inserted at the beginning of each line.如果
n < 0
然后最多n
空白字符 从每行的开头删除。如果给定行不包含足够的空白,则所有前导 空白字符 都将被删除。每个空白字符都被视为单个字符。特别是,制表符"\t"
(U+0009) 被认为是单个字符;它没有扩展。如果
n == 0
则该行保持不变。但是,行终止符仍然是规范化的。- 参数:
n
- 要添加或删除的前导 空白字符 的数量- 返回:
- 缩进调整和行尾规范化的字符串
- 自从:
- 12
- 参见:
-
stripIndent
返回一个字符串,其值为该字符串,并从每行的开头和结尾删除附带的 空白。附带的 空白 通常出现在文本块中,以使内容与开始定界符对齐。例如,在以下代码中,点代表附带的 空白 :
String html = """ ..............<html> .............. <body> .............. <p>Hello, world</p> .............. </body> ..............</html> ..............""";
|<html> | <body> | <p>Hello, world</p> | </body> |</html>
然后,最小缩进(分钟)确定如下:
这minvalue 是这些计数中最小的。
对于每个 非空白 行,min删除前导 空白 个字符,并删除任何尾随 空白 个字符。 空白的 行被替换为空字符串。
最后,这些行被连接成一个新的字符串,使用 LF 字符
"\n"
(U+000A) 来分隔行。 -
translateEscapes
返回一个字符串,其值为该字符串,转义序列被翻译成字符串文字。转义序列翻译如下;
逃脱 Name 翻译 \b
退格键 U+0008
\t
水平制表符 U+0009
\n
换行 U+000A
\f
换页 U+000C
\r
回车 U+000D
\s
空间 U+0020
\"
双引号 U+0022
\'
单引号 U+0027
\\
反斜杠 U+005C
\0 - \377
八进制转义 代码点等价物 \<line-terminator>
继续 丢弃 - 实现注意事项:
-
此方法确实not 转换 Unicode 转义符,例如“
\u2022
”。 Unicode 转义由 Java 编译器在读取输入字符时进行翻译,它不是字符串文字规范的一部分。 - 返回:
- 已翻译转义序列的字符串。
- 抛出:
IllegalArgumentException
- 当转义序列格式错误时。- 看Java 语言规范:
-
3.10.7 转义序列
- 自从:
- 15
-
transform
此方法允许将函数应用到this
字符串。该函数应该期望一个 String 参数并产生一个R
结果。f.apply()
抛出的任何异常都将传播给调用者。- 类型参数:
R
- 结果的类型- 参数:
f
- 要应用的函数- 返回:
- 将函数应用于此字符串的结果
- 自从:
- 12
- 参见:
-
toString
这个对象(已经是一个字符串!)本身被返回。- 指定者:
toString
在接口CharSequence
中- 重写:
toString
在类Object
中- 返回:
- 字符串本身。
-
chars
- 指定者:
chars
在接口CharSequence
中- 返回:
- 来自此序列的 char 值的 IntStream
- 自从:
- 9
-
codePoints
返回此序列中的代码点值流。序列中遇到的任何代理对都被组合为 Character.toCodePoint 并将结果传递给流。任何其他代码单元,包括普通 BMP 字符、未配对的代理项和未定义的代码单元,都被零扩展为int
值,然后传递给流。- 指定者:
codePoints
在接口CharSequence
中- 返回:
- 来自此序列的 Unicode 代码点的 IntStream
- 自从:
- 9
-
toCharArray
public char[] toCharArray()将此字符串转换为新的字符数组。- 返回:
- 一个新分配的字符数组,其长度是该字符串的长度,其内容被初始化为包含该字符串表示的字符序列。
-
format
使用指定的格式字符串和参数返回格式化字符串。始终使用的locale是
Locale.getDefault(Locale.Category)
返回的locale,其中指定了FORMAT
类别。- 参数:
format
- 一个 格式字符串args
- 格式字符串中格式说明符引用的参数。如果参数多于格式说明符,则忽略多余的参数。参数的数量是可变的,可以为零。参数的最大数量受限于 Java 数组的最大维度,如定义的那样Java 虚拟机规范null
参数的行为取决于 转换 。- 返回:
- 格式化的字符串
- 抛出:
IllegalFormatException
- 如果格式字符串包含非法语法、与给定参数不兼容的格式说明符、给定格式字符串的参数不足或其他非法条件。有关所有可能的格式错误的规范,请参阅格式化程序类规范的细节部分。- 自从:
- 1.5
- 参见:
-
format
使用指定的locale、格式字符串和参数返回格式化字符串。- 参数:
l
- 在格式化期间应用的 locale。如果l
是null
则不应用本地化。format
- 一个 格式字符串args
- 格式字符串中格式说明符引用的参数。如果参数多于格式说明符,则忽略多余的参数。参数的数量是可变的,可以为零。参数的最大数量受限于 Java 数组的最大维度,如定义的那样Java 虚拟机规范null
参数的行为取决于 转换 。- 返回:
- 格式化的字符串
- 抛出:
IllegalFormatException
- 如果格式字符串包含非法语法、与给定参数不兼容的格式说明符、给定格式字符串的参数不足或其他非法条件。有关所有可能的格式错误的规范,请参阅格式化程序类规范的细节部分- 自从:
- 1.5
- 参见:
-
formatted
使用此字符串作为格式字符串和提供的参数的格式。- 实现要求:
-
此方法等效于
String.format(this, args)
。 - 参数:
args
- 此字符串中格式说明符引用的参数。- 返回:
- 格式化的字符串
- 自从:
- 15
- 参见:
-
valueOf
返回Object
参数的字符串表示形式。- 参数:
obj
- 一个Object
。- 返回:
-
如果参数是
null
,那么一个字符串等于"null"
;否则,返回obj.toString()
的值。 - 参见:
-
valueOf
返回char
数组参数的字符串表示形式。复制字符数组的内容;字符数组的后续修改不会影响返回的字符串。- 参数:
data
- 字符数组。- 返回:
-
包含字符数组字符的
String
。
-
valueOf
返回char
数组参数的特定子数组的字符串表示形式。offset
参数是子数组第一个字符的索引。count
参数指定子数组的长度。复制子数组的内容;字符数组的后续修改不会影响返回的字符串。- 参数:
data
- 字符数组。offset
- 子数组的初始偏移量。count
- 子数组的长度。- 返回:
-
一个
String
,它包含字符数组的指定子数组的字符。 - 抛出:
IndexOutOfBoundsException
- 如果offset
为负数,或count
为负数,或offset+count
大于data.length
。
-
copyValueOf
- 参数:
data
- 字符数组。offset
- 子数组的初始偏移量。count
- 子数组的长度。- 返回:
-
一个
String
,它包含字符数组的指定子数组的字符。 - 抛出:
IndexOutOfBoundsException
- 如果offset
为负数,或count
为负数,或offset+count
大于data.length
。
-
copyValueOf
相当于valueOf(char[])
。- 参数:
data
- 字符数组。- 返回:
-
包含字符数组字符的
String
。
-
valueOf
返回boolean
参数的字符串表示形式。- 参数:
b
- 一个boolean
。- 返回:
-
如果参数是
true
,则返回等于"true"
的字符串;否则,返回等于"false"
的字符串。
-
valueOf
返回char
参数的字符串表示形式。- 参数:
c
- 一个char
。- 返回:
-
长度为
1
的字符串,其中包含参数c
作为其单个字符。
-
valueOf
返回int
参数的字符串表示形式。该表示正是
Integer.toString
方法返回的一个参数。- 参数:
i
- 一个int
。- 返回:
int
参数的字符串表示形式。- 参见:
-
valueOf
返回long
参数的字符串表示形式。该表示正是
Long.toString
方法返回的一个参数。- 参数:
l
- 一个long
。- 返回:
long
参数的字符串表示形式。- 参见:
-
valueOf
返回float
参数的字符串表示形式。该表示正是
Float.toString
方法返回的一个参数。- 参数:
f
- 一个float
。- 返回:
float
参数的字符串表示形式。- 参见:
-
valueOf
返回double
参数的字符串表示形式。该表示正是
Double.toString
方法返回的一个参数。- 参数:
d
- 一个double
。- 返回:
double
参数的字符串表示形式。- 参见:
-
intern
返回字符串对象的规范表示。字符串池最初为空,由类
String
私下维护。调用 intern 方法时,如果池中已经包含等于
equals(Object)
方法确定的此String
对象的字符串,则返回池中的字符串。否则,会将此String
对象添加到池中并返回对此String
对象的引用。由此得出,对于任意两个字符串
s
和t
,当且仅当s.equals(t)
是true
时,s.intern() == t.intern()
是true
。所有文字字符串和字符串值常量表达式都是驻留的。字符串文字在 3.10.5 节中定义Java 语言规范.
- 返回:
- 与此字符串具有相同内容的字符串,但保证来自唯一字符串池。
-
repeat
返回一个字符串,其值是此字符串重复count
次的串联。如果此字符串为空或计数为零,则返回空字符串。
- 参数:
count
- 重复次数- 返回:
-
由该字符串重复
count
次组成的字符串,如果该字符串为空或计数为零,则为空字符串 - 抛出:
IllegalArgumentException
- 如果count
为负。- 自从:
- 11
-
describeConstable
返回一个Optional
,其中包含此实例的标称描述符,即实例本身。- 指定者:
describeConstable
在接口Constable
中- 返回:
Optional
描述了 String 实例- 自从:
- 12
-
resolveConstantDesc
将此实例解析为ConstantDesc
,其结果是实例本身。- 指定者:
resolveConstantDesc
在接口ConstantDesc
中- 参数:
lookup
- 忽略- 返回:
- String 实例
- 自从:
- 12
-