|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
上一个类 下一个类 | 框架 无框架 | |||||||||
摘要: 嵌套 | 字段 | 构造方法 | 方法 | 详细信息: 字段 | 构造方法 | 方法 |
java.lang.Object java.lang.String
public final class String
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 Standard 版本。
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
值)的方法。
Object.toString()
,
StringBuffer
,
StringBuilder
,
Charset
,
序列化表格字段摘要 | |
---|---|
static Comparator<String> |
CASE_INSENSITIVE_ORDER
一个排序 String 对象的 Comparator,它的作用与 compareToIgnoreCase 相同。 |
构造方法摘要 | |
---|---|
String()
初始化一个新创建的 String 对象,它表示一个空字符序列。 |
|
String(byte[] bytes)
构造一个新的 String,方法是使用平台的默认字符集解码字节的指定数组。 |
|
String(byte[] ascii,
int hibyte)
已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 起,完成该转换的首选方法是通过 String 构造方法,该方法接受一个字符集名称或使用平台的默认字符集。 |
|
String(byte[] bytes,
int offset,
int length)
构造一个新的 String,方法是使用指定的字符集解码字节的指定子数组。 |
|
String(byte[] ascii,
int hibyte,
int offset,
int count)
已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 开始,完成该转换的首选方法是通过 String 构造方法,它接受一个字符集名称,或者使用平台默认的字符集。 |
|
String(byte[] bytes,
int offset,
int length,
String charsetName)
构造一个新的 String,方法是使用指定的字符集解码字节的指定子数组。 |
|
String(byte[] bytes,
String charsetName)
构造一个新的 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)
当且仅当此 String 表示与指定序列相同的 char 值时,才返回 true。 |
boolean |
contentEquals(StringBuffer sb)
当且仅当此 String 表示与指定的 StringBuffer 相同的字符序列时,才返回 true。 |
static String |
copyValueOf(char[] data)
返回指定数组中表示该字符序列的字符串。 |
static String |
copyValueOf(char[] data,
int offset,
int count)
返回指定数组中表示该字符序列的字符串。 |
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 解码为字节序列,并将结果存储到一个新的字节数组中。 |
void |
getBytes(int srcBegin,
int srcEnd,
byte[] dst,
int dstBegin)
已过时。 该方法无法将字符正确转换为字节。从 JDK 1.1 起,完成该转换的首选方法是通过 getBytes() 构造方法,该方法使用平台的默认字符集。 |
byte[] |
getBytes(String charsetName)
使用指定的字符集将此 String 解码为字节序列,并将结果存储到一个新的字节数组中。 |
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()
返回字符串对象的规范化表示形式。 |
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 |
字段详细信息 |
---|
public static final Comparator<String> CASE_INSENSITIVE_ORDER
String
对象的 Comparator,它的作用与 compareToIgnoreCase
相同。该比较器是可序列化的。
注意,Comparator 未 考虑到语言环境,因此可能导致在某些语言环境中排序效果不理想。java.text 包提供 Collators 来完成语言环境敏感的排序。
Collator.compare(String, String)
构造方法详细信息 |
---|
public String()
String
对象,它表示一个空字符序列。注意,由于 String 是不可变的,不必使用该构造方法。
public String(String original)
String
对象,表示一个与该参数相同的字符序列;换句话说,新创建的字符串是该参数字符串的一个副本。由于 String 是不可变的,不必使用该构造方法,除非需要 original
的显式副本。
original
- 一个 String
。public String(char[] value)
String
,它表示当前字符数组参数中包含的字符序列。该字符数组的内容已被复制;后续对字符数组的修改不会影响新创建的字符串。
value
- 此字符串的初始值。public String(char[] value, int offset, int count)
String
,它包含来自该字符数组参数的一个子数组的字符。offset
参数是子数组第一个字符的索引,count
参数指定子数组的长度。该子数组的内容已被复制;后续对字符数组的修改不会影响新创建的字符串。
value
- 作为字符源的数组。offset
- 初始偏移量。count
- 长度。
IndexOutOfBoundsException
- 如果 offset
和 count
参数索引字符超出 value
数组的范围。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
数组的范围。@Deprecated public String(byte[] ascii, int hibyte, int offset, int count)
String
构造方法,它接受一个字符集名称,或者使用平台默认的字符集。
String
,它根据一个 8 位整数值数组的子数组构造。
offset
参数是该子数组的第一个字节的索引,count
参数指定子数组的长度。
子数组中的每个 byte
都按照上述方法转换为 char
。
ascii
- 要转换为字符的字节。hibyte
- 每个 16 位 Unicode 字符的前 8 位。offset
- 初始偏移量。count
- 长度。
IndexOutOfBoundsException
- 如果 offset
或 count
参数无效。String(byte[], int)
,
String(byte[], int, int, java.lang.String)
,
String(byte[], int, int)
,
String(byte[], java.lang.String)
,
String(byte[])
@Deprecated public String(byte[] ascii, int hibyte)
String
构造方法,该方法接受一个字符集名称或使用平台的默认字符集。
String
,它包含的字符根据一个 8 位整数值的数组构造。得到的字符串中的每个字符 c 都根据字节数组中的相应部分 b 构造,如下所示:
c == (char)(((hibyte & 0xff) << 8) | (b & 0xff))
ascii
- 要转换为字符的字节。hibyte
- 每个 16 位 Unicode 字符的前 8 位。String(byte[], int, int, java.lang.String)
,
String(byte[], int, int)
,
String(byte[], java.lang.String)
,
String(byte[])
public String(byte[] bytes, int offset, int length, String charsetName) throws UnsupportedEncodingException
当给定字节在给定字符集中无效的情况下,该构造方法无指定的行为。当需要进一步控制解码过程时,应使用 CharsetDecoder
类。
bytes
- 要解码为字符的字节offset
- 要解码的首字节的索引length
- 要解码的字节数charsetName
- 受支持的
charset
的名称
UnsupportedEncodingException
- 如果指定的字符集不受支持
IndexOutOfBoundsException
- 如果 offset 和 length 参数索引字符超出 bytes 数组的范围public String(byte[] bytes, String charsetName) throws UnsupportedEncodingException
当给定字节在给定字符集中无效的情况下,该构造方法无指定的行为。当需要进一步控制解码过程时,应使用 CharsetDecoder
类。
bytes
- 要解码为字符的字节charsetName
- 受支持的
charset
的名称
UnsupportedEncodingException
- 如果指定字符集不受支持public String(byte[] bytes, int offset, int length)
当给定字节在给定字符集中无效的情况下,该构造方法无指定的行为。当需要进一步控制解码过程时,应使用 CharsetDecoder
类。
bytes
- 要解码为字符的字节offset
- 要解码的首字节的索引length
- 要解码的字节数
IndexOutOfBoundsException
- 如果 offset
和 length
参数索引字符超出 bytes
数组的范围public String(byte[] bytes)
当给定字节在给定字符集中无效的情况下,该构造方法无指定的行为。当需要进一步控制解码过程时,应使用 CharsetDecoder
类。
bytes
- 要解码为字符的字节public String(StringBuffer buffer)
buffer
- 一个 StringBuffer
。public String(StringBuilder builder)
提供该构造方法以简化到 StringBuilder
的迁移。通过 toString
方法从字符串生成器中获得字符串可能是一种更快的方法,因此通常作为首选。
builder
- 一个 StringBuilder
方法详细信息 |
---|
public int length()
CharSequence
中的 length
public char charAt(int index)
char
值。索引范围为从 0
到 length() - 1
。序列的第一个 char
值在索引 0
处,第二个在索引 1
处,依此类推,这类似于数组索引。
如果索引指定的 char
值是代理项,则返回代理项值。
CharSequence
中的 charAt
index
- char
值的索引。
char
值。第一个 char
值在索引 0
处。
IndexOutOfBoundsException
- 如果 index
参数为负或小于此字符串的长度。public int codePointAt(int index)
char
值(Unicode 代码单元),其范围从 0
到 length()
- 1
。
如果给定索引指定的 char
值属于高代理项范围,则后续索引小于此 String
的长度。同样,如果后续索引处的 char
值属于低代理项范围,则返回该代理项对相应的增补代码点。否则,返回给定索引处的 char
值。
index
- char
值的索引
index
处字符的代码点值
IndexOutOfBoundsException
- 如果 index
参数为负或小于此字符串的长度。public int codePointBefore(int index)
char
值(Unicode 代码单元),其范围从 1
到 length
。
如果 (index - 1)
处的 char
值属于低代理项范围,则 (index - 2)
为非负;如果(index - 2)
处的 char
值属于高低理项范围,则返回该代理项对的增补代码点值。如果 index - 1
处的 char
值是未配对的低(高)代理项,则返回代理项值。
index
- 应返回的代码点后面的索引
IndexOutOfBoundsException
- 如果 index
参数小于 1 或大于此字符串的长度。public int codePointCount(int beginIndex, int endIndex)
String
的指定文本范围中的 Unicode 代码点数。文本范围始于指定的 beginIndex
,一直到索引 endIndex - 1
处的 char
。因此,该文本范围的长度(在 char
中)是 endIndex-beginIndex
。该文本范围内未配对的代理项作为一个代码点计数。
beginIndex
- 该文本范围的第一个 char
的索引。endIndex
- 该文本范围的最后一个 char
后面的索引。
IndexOutOfBoundsException
- 如果 beginIndex
为负,或 endIndex
大于此 String
的长度,或 beginIndex
大于 endIndex
。public int offsetByCodePoints(int index, int codePointOffset)
String
中从给定的 index
处偏移 codePointOffset
个代码点的索引。文本范围内由 index
和 codePointOffset
给定的未配对代理项各计为一个代码点。
index
- 要偏移的索引codePointOffset
- 代码点中的偏移量
String
的索引
IndexOutOfBoundsException
- 如果 index
为负或大于此 String
的长度;或者 codePointOffset
为正,并且以 index
开头的子字符串比 codePointOffset
具有更少的代码点;如果 codePointOffset
为负,并且 index
前的子字符串比 codePointOffset
的绝对值具有更少的代码点。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
@Deprecated public void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)
getBytes()
构造方法,该方法使用平台的默认字符集。
要复制的第一个字符在索引 srcBegin
处;要复制的最后一个字符在索引 srcEnd-1
处。要复制的字符总数为 srcEnd-srcBegin
。将要转换为字节的字符复制到 dst
的子数组中,从索引 dstBegin
处开始,并结束于索引:
dstbegin + (srcEnd-srcBegin) - 1
srcBegin
- 字符串中要复制的第一个字符的索引。srcEnd
- 字符串中要复制的最后一个字符之后的索引。dst
- 目标数组。dstBegin
- 目标数组中的起始偏移量。
IndexOutOfBoundsException
- 如果下列任何一项为 true:
srcBegin
为负
srcBegin
大于 srcEnd
srcEnd
大于此 String 的长度
dstBegin
为负
dstBegin+(srcEnd-srcBegin)
大于 dst.length
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException
当此字符串不能在给定的字符集中解码时,该方法无指定的行为。当需要进一步控制解码过程时,应使用 CharsetEncoder
类。
charsetName
- 受支持的
charset
名称
UnsupportedEncodingException
- 如果指定的字符集不受支持public byte[] getBytes()
当此字符串不能在默认的字符集中解码时,该方法无指定的行为。当需要进一步控制解码过程时,应使用 CharsetEncoder
类。
public boolean equals(Object anObject)
null
,并且是表示与此对象相同的字符序列的 String
对象时,结果才为 true
。
Object
中的 equals
anObject
- 与此 String
进行比较的对象。
String
相等,则返回 true
;否则返回 false
。compareTo(java.lang.String)
,
equalsIgnoreCase(java.lang.String)
public boolean contentEquals(StringBuffer sb)
sb
- 要比较的 StringBuffer。
NullPointerException
- 如果 sb
为 null
public boolean contentEquals(CharSequence cs)
cs
- 要比较的序列。
NullPointerException
- 如果 cs
为 null
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)
,
Character.toLowerCase(char)
,
Character.toUpperCase(char)
public int compareTo(String anotherString)
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
的值。public int compareToIgnoreCase(String str)
compareTo
的正负号,调用时使用了字符串的规范化版本,其大小写差异已通过对每个字符调用 Character.toLowerCase(Character.toUpperCase(character))
得以消除。
注意,此方法不 考虑语言环境,因此可能在某些特定的语言环境中产生不理想的排序。java.text 包提供 Collators 来完成语言环境敏感的排序。
str
- 要比较的 String
。
Collator.compare(String, String)
public boolean regionMatches(int toffset, String other, int ooffset, int len)
该 String 对象的一个子字符串与参数 other 的一个子字符串进行比较。如果这两个子字符串表示相同的字符序列,则结果为 true。要比较的 String 对象的子字符串从索引 toffset 处开始,长度为 len。要比较的 other 的子字符串从索引 ooffset 处开始,长度为 len。当且仅当下列至少一项为 true 时,结果才为 false :
toffset
- 字符串中子区域的起始偏移量。other
- 字符串参数。ooffset
- 字符串参数中子区域的起始偏移量。len
- 要比较的字符数。
true
;否则返回 false
。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:
this.charAt(toffset+k) != other.charAt(ooffset+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
参数。public boolean startsWith(String prefix, int toffset)
prefix
- 前缀。toffset
- 在字符串中开始查找的位置。
toffset
处开始的子字符串,则返回 true
;否则返回 false
。如果 toffset
为负或大于此 String
对象的长度,则结果为 false
;否则结果与该表达式的结果相同。
this.substring(toffset).startsWith(prefix)
public boolean startsWith(String prefix)
prefix
- 前缀。
true
;否则为 false
。还要注意,如果参数是空字符串,或者等于由 equals(Object)
方法确定的 String
对象,则返回 true
。public boolean endsWith(String suffix)
suffix
- 后缀。
true
;否则返回 false
。注意,如果该参数是空字符串或等于由 equals(Object)
方法确定的 String
对象,则结果为 true
。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
public int indexOf(int ch)
String
对象表示的字符序列中出现值为 ch
的字符,则返回第一次出现该字符的索引(以 Unicode 代码单元表示)。对于位于 0 到 0xFFFF(包括 0 和 0xFFFF)范围内的 ch
的值,返回值是
为 true 的最小值 k。对于this.charAt(k) == ch
ch
的其他值,返回值是
为 true 最小值 k。无论哪种情况,如果此字符串中没有这样的字符,则返回this.codePointAt(k) == ch
-1
。
ch
- 一个字符(Unicode 代码点)。
-1
。public int indexOf(int ch, int fromIndex)
在此 String
对象表示的字符序列中,如果带有值 ch
的字符的索引不小于 fromIndex
,则返回第一次出现该值的索引。对于位于 0 到 0xFFFF(包括 0 和 0xFFFF)范围内的 ch
值,返回值是
为 true 的最小值 k。对于(this.charAt(k) == ch) && (k >= fromIndex)
ch
的其他值,返回值是
为 true 的最小值 k。在任何情况下,如果此字符串中没有这样的字符在位置(this.codePointAt(k) == ch) && (k >= fromIndex)
fromIndex
处或其后出现,则返回 -1
。
fromIndex
的值没有限制。如果它为负,它和 0 具有同样的效果:将搜索整个字符串。如果它大于此字符串的长度,则它具有等于此字符串长度的相同效果:返回 -1
。
所有索引都在 char
值中指定(Unicode 代码单元)。
ch
- 一个字符(Unicode 代码点)。fromIndex
- 开始搜索的索引。
fromIndex
的字符的索引,如果未出现该字符,则返回 -1
。public int lastIndexOf(int ch)
ch
的值,返回的索引(Unicode 代码单元)是
为 true 最大值 k。对于this.charAt(k) == ch
ch
的其他值,即为
为 true 的最大值 k。在任一种情况下,如果此字符串中没有这样的字符出现,则返回this.codePointAt(k) == ch
-1
。从最后一个字符开始后向搜索此 String
。
ch
- 一个字符(Unicode 代码点)。
-1
。public int lastIndexOf(int ch, int fromIndex)
ch
值,返回的索引是
为 true 的最大值 k。对于(this.charAt(k) == ch) && (k <= fromIndex)
ch
的其他值,即为
为 true 的最大值 k。在任一种情况下,如果此字符串中没有这样的字符在位置(this.codePointAt(k) == ch) && (k <= fromIndex)
fromIndex
处或其前出现,则返回 -1
。
所有的索引都以 char
值指定(Unicode 代码单元)。
ch
- 一个字符(Unicode 代码点)。fromIndex
- 开始搜索的索引。fromIndex
的值没有限制。如果它大于或等于此字符串的长度,则它具有与小于此字符串长度的相同效果:将搜索整个字符串。如果它为负,则它的效果与它为 -1 是相同的:返回 -1。
fromIndex
的字符的索引,如果在该点之前未出现该字符,则返回 -1
。public int indexOf(String str)
为this.startsWith(str, k)
true
的最小值 k。
str
- 任意字符串。
-1
。public int indexOf(String str, int fromIndex)
如果不存在这样的 k 值,则返回 -1。k >= Math.min(fromIndex, str.length()) && this.startsWith(str, k)
str
- 要搜索的子字符串。fromIndex
- 开始搜索的索引位置。
public int lastIndexOf(String str)
this.length()
处。返回的索引是
为 true 的最大值 k。this.startsWith(str, k)
str
- 要搜索的子字符串。
-1
。public int lastIndexOf(String str, int fromIndex)
如果不存在这样的 k 值,则返回 -1。k <= Math.min(fromIndex, str.length()) && this.startsWith(str, k)
str
- 要搜索的子字符串。fromIndex
- 开始搜索的索引位置。
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
对象的长度。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
。public CharSequence subSequence(int beginIndex, int endIndex)
这种形式的方法调用:
与下列方法调用完全相同:str.subSequence(begin, end)
定义此方法以使 String 类能够实现str.substring(begin, end)
CharSequence
接口。
CharSequence
中的 subSequence
beginIndex
- 开始处的索引(包括)。endIndex
- 结束处的索引(不包括)。
IndexOutOfBoundsException
- 如果 beginIndex 或 endIndex 为负,如果 endIndex 大于 length() 或 beginIndex 大于 startIndexpublic String concat(String str)
如果参数字符串的长度为 0
,则返回此 String
对象。否则,创建一个新的 String
对象,用来表示由此 String
对象表示的字符序列和由参数字符串表示的字符序列串联而成的字符序列。
示例:
"cares".concat("s") returns "caress" "to".concat("get").concat("her") returns "together"
str
- 串联到此 String
结尾的 String
。
public String replace(char oldChar, char newChar)
newChar
替换此字符串中出现的所有 oldChar
而生成的。
如果 oldChar
在此 String
对象表示的字符序列中没有出现,则返回对此 String
对象的引用。否则,创建一个新的 String
对象,用来表示与此 String
对象表示的字符序列相等的字符序列,除了每个出现的 oldChar
都被一个 newChar
替换之外。
示例:
"mesquite in your cellar".replace('e', 'o') returns "mosquito in your collar" "the war of baronets".replace('r', 'y') returns "the way of bayonets" "sparring with a purple porpoise".replace('p', 't') returns "starring with a turtle tortoise" "JonL".replace('q', 'x') returns "JonL" (no change)
oldChar
- 原来的字符。newChar
- 新字符。
oldChar
的地方用 newChar
替换。public boolean matches(String regex)
此方法调用的 str.matches(regex) 形式与以下表达式产生完全相同的结果:
Pattern
.matches
(regex, str)
regex
- 用来匹配此字符串的正则表达式
PatternSyntaxException
- 如果正则表达式的语法无效Pattern
public boolean contains(CharSequence s)
s
- 要搜索的序列
s
,则返回 true,否则返回 false
NullPointerException
- 如果 s
为 null
public String replaceFirst(String regex, String replacement)
此方法调用的 str.replaceFirst(regex, repl) 形式产生与以下表达式完全相同的结果:
Pattern
.compile
(regex).matcher
(str).replaceFirst
(repl)
regex
- 用来匹配此字符串的正则表达式
PatternSyntaxException
- 如果正则表达式的语法无效Pattern
public String replaceAll(String regex, String replacement)
此方法调用的 str.replaceAll(regex, repl) 形式产生与以下表达式完全相同的结果:
Pattern
.compile
(regex).matcher
(str).replaceAll
(repl)
regex
- 用来匹配此字符串的正则表达式
PatternSyntaxException
- 如果正则表达式的语法无效Pattern
public String replace(CharSequence target, CharSequence replacement)
target
- 要被替换的 char 值序列replacement
- char 值的替换序列
NullPointerException
- 如果 target
或 replacement
为 null
。public String[] split(String regex, int limit)
此方法返回的数组包含此字符串的每个子字符串,这些子字符串由另一个匹配给定的表达式的子字符串终止或由字符串结束来终止。数组中的子字符串按它们在此字符串中的顺序排列。如果表达式不匹配输入的任何部分,则结果数组只具有一个元素,即此字符串。
limit 参数控制模式应用的次数,因此影响结果数组的长度。如果该限制 n 大于 0,则模式将被最多应用 n - 1 次,数组的长度将不会大于 n,而且数组的最后项将包含超出最后匹配的定界符的所有输入。如果 n 为非正,则模式将被应用尽可能多的次数,而且数组可以是任意长度。如果 n 为零,则模式将被应用尽可能多的次数,数组可有任何长度,并且结尾空字符串将被丢弃。
例如,字符串 "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
- 如果正则表达式的语法无效Pattern
public String[] split(String regex)
该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split
方法。因此,结果数组中不包括结尾空字符串。
例如,字符串 "boo:and:foo" 产生带有下面这些表达式的结果:
Regex 结果 : { "boo", "and", "foo" } o { "b", "", ":and:f" }
regex
- 定界正则表达式
PatternSyntaxException
- 如果正则表达式的语法无效Pattern
public String toLowerCase(Locale locale)
Locale
的规则将此 String
中的所有字符都转换为小写。大小写映射关系基于由 Character
类指定的 Unicode Standard 版本。由于大小写映射关系并不总是 1:1 的字符映射关系,得到的 String
可能具有不同于原始 String
的长度。
下表中给出了几个小写映射关系的例子:
语言环境的代码 | 大写字母 | 小写字母 | 描述 |
---|---|---|---|
tr (Turkish) | \u0130 | \u0069 | 大写字母 I,上面有点 -> 小写字母 i |
tr (Turkish) | \u0049 | \u0131 | 大写字母 I -> 小写字母 i,无点 |
(all) | French Fries | french fries | 将字符串中的所有字符都小写 |
(all) | 将字符串中的所有字符都小写 |
locale
- 使用此语言环境的大小写转换规则
String
。toLowerCase()
,
toUpperCase()
,
toUpperCase(Locale)
public String toLowerCase()
String
中的所有字符都转换为小写。这等效于调用 toLowerCase(Locale.getDefault())
。
String
。toLowerCase(Locale)
public String toUpperCase(Locale locale)
Locale
规则将此 String
中的所有字符都转换为大写。大小写映射关系基于由 Character
类指定的 Unicode Standard 版本。由于大小写映射关系并不总是 1:1 的字符映射关系,得到的 String
可能具有不同于原始 String
的长度。
下表中是语言环境敏感和 1:M 大小写映射关系的一些例子。
语言环境的代码 | 小写 | 大写 | 描述 |
---|---|---|---|
tr (Turkish) | \u0069 | \u0130 | 小写字母 i -> 大写字母 I,上面有点 |
tr (Turkish) | \u0131 | \u0049 | 无点的小写字母 -> 大写字母 I |
(all) | \u00df | \u0053 \u0053 | 小写字母 sharp s -> 两个字母:SS |
(all) | Fahrvergnügen | FAHRVERGNÜN |
locale
- 用于此语言环境的大小写转换规则
String
。toUpperCase()
,
toLowerCase()
,
toLowerCase(Locale)
public String toUpperCase()
String
中的所有字符都转换为大写。此方法等效于toUpperCase(Locale.getDefault())
。
String
。toUpperCase(Locale)
public String trim()
如果此 String
对象表示一个空字符序列,或者此 String
对象表示的字符序列的第一个和最后一个字符的代码都大于 '\u0020'
(空格字符),则返回对此 String
对象的引用。
否则,若字符串中没有代码大于 '\u0020'
的字符,则创建并返回一个表示空字符串的新的 String
对象。
否则,假定 k 为代码大于 '\u0020'
的第一个字符的索引,m 为代码大于 '\u0020'
的最后一个字符的索引。创建一个新的 String
对象,它表示此字符串中从索引 k 处的字符开始,到索引 m 处的字符结束的子字符串,也就是 this.substring(k, m+1)
的结果。
此方法用于截去字符串从头到尾的空白(如上面所定义)。
public String toString()
CharSequence
中的 toString
Object
中的 toString
public char[] toCharArray()
public static String format(String format, Object... args)
始终使用的语言环境是由 Locale.getDefault()
返回的语言环境。
format
- 格式字符串args
- 在格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数,则忽略这些额外的参数。参数是可变的并且可以为 0。参数的最大数目受《Java Virtual Machine Specification》所定义的 Java 数组的最大维度的限制。针对 null 参数的行为依赖于 转换。
IllegalFormatException
- 如果格式字符串中包含非法语法,与给定的参数不兼容的格式说明符,格式字符串给定的参数不够,或存在其他非法条件。有关所有可能的格式化错误的规范,请参阅 formatter 类规范的 Details 一节。
NullPointerException
- 如果 format 为 nullFormatter
public static String format(Locale l, String format, Object... args)
l
- 在格式化过程中要应用的语言环境。如果 l 为 null,则不进行本地化。format
- 格式字符串args
- 在格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数,则忽略这些额外的参数。参数的数量是可变的,并且可以为零。参数的最大数目受《Java Virtual Machine Specification》所定义的 Java 数组的最大维度的限制。针对 null 参数的行为依赖于转换。
IllegalFormatException
- 如果格式字符串中包含非法语法,与给定参数不兼容的格式说明符,格式字符串给定的参数不够,或存在其他非法条件。有关所有可能的格式化错误的规范,请参阅 formatter 类规范的 Details 一节。
NullPointerException
- 如果 format 为 nullFormatter
public static String valueOf(Object obj)
Object
参数的字符串表示形式。
obj
- 一个 Object
。
null
,则字符串等于 "null"
;否则,返回 obj.toString()
的值。Object.toString()
public static String valueOf(char[] data)
char
数组参数的字符串表示形式。字符数组的内容已被复制,后续修改不会影响新创建的字符串。
data
- char
数组。
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
。public static String copyValueOf(char[] data, int offset, int count)
data
- 字符数组。offset
- 子数组的初始偏移量。count
- 子数组的长度。
String
,它包含字符数组的指定子数组的字符。public static String copyValueOf(char[] data)
data
- 字符数组。
String
,它包含字符数组的字符。public static String valueOf(boolean b)
boolean
参数的字符串表示形式。
b
- 一个 boolean
。
true
,返回一个等于 "true"
的字符串;否则,返回一个等于 "false"
的字符串。public static String valueOf(char c)
char
参数的字符串表示形式。
c
- 一个 char
。
1
的字符串,它包含参数 c
的单个字符。public static String valueOf(int i)
int
参数的字符串表示形式。
该表示形式恰好是单参数的 Integer.toString
方法返回的结果。
i
- 一个 int
。
int
参数的字符串表示形式。Integer.toString(int, int)
public static String valueOf(long l)
long
参数的字符串表示形式。
该表示形式恰好是单参数的 Long.toString
方法返回的结果。
l
- 一个 long
。
long
参数的字符串表示形式。Long.toString(long)
public static String valueOf(float f)
float
参数的字符串表示形式。
该表示形式恰好是单参数的 Float.toString
方法返回的结果。
f
- 一个 float
。
float
参数的字符串表示形式。Float.toString(float)
public static String valueOf(double d)
double
参数的字符串表示形式。
该表示形式恰好是单参数的 Double.toString
方法返回的结果。
d
- 一个 double
。
double
参数的字符串表示形式。Double.toString(double)
public String intern()
一个初始时为空的字符串池,它由类 String
私有地维护。
当调用 intern 方法时,如果池已经包含一个等于此 String
对象的字符串(该对象由 equals(Object)
方法确定),则返回池中的字符串。否则,将此 String
对象添加到池中,并且返回此 String
对象的引用。
它遵循对于任何两个字符串 s
和 t
,当且仅当 s.equals(t)
为 true
时,s.intern() == t.intern()
才为 true
。
所有字面值字符串和字符串赋值常量表达式都是内部的。字符串字面值在《Java Language Specification》的 §3.10.5 中已定义。
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
上一个类 下一个类 | 框架 无框架 | |||||||||
摘要: 嵌套 | 字段 | 构造方法 | 方法 | 详细信息: 字段 | 构造方法 | 方法 |
版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。