类 java.lang.String
java.lang.Object
|
+----java.lang.String
--------------------------------------------------------------------------------
public final class String
extends Object
implements Serializable
String 类表示字符串。 在 Java 程序中所有的字符串常量，如 "abc"，都被实现为这个类的实例。
字符串是常量；他们的值在生成后不能改变。字符串缓冲区支持可变的字符串。 因为字符串对象是不可变的，所以它们可以被共享。 例如:
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 类包括检查字符串序列中单个字符的方法，这些方法用于比较字符串、查找字符串、抽取子字符串、生成一个字符串拷贝和把所有字符都转换为大写或小写。
Java 语言提供对字符串连接操作符 ( + )和其它字符串对象相互转换的特殊支持。 字符串连结是通过 StringBuffer 类和它的 append 方法实现的。 字符串转换是通过 toString 方法实现的，该方法由 Object 定义并且被 Java 中的所有类继承。 关于字符串连结和转换的其它信息 ， 参见 Gosling 、Joy、和 Steele 的书 Java 语言规范 。
来自:
JDK1.0
参见:
toString, StringBuffer, append, append, append, append, append, append, append, append, append, append
--------------------------------------------------------------------------------
构造子索引
String()
分配一个新的不含有字符的 String 。
String(byte[])
用平台的缺省字符编码方式转换指定的字节数组生成一个新的 String 。
String(byte[], int)
分配一个新的 String ，它包含有从一8位整型数组构造得到的字符。 不推荐使用该方法。
String(byte[], int, int)
使用平台的缺省字符编码方式转换指定的字节子数组生成一新的 String
String(byte[], int, int, int)
分配一新的 String ，它包含有从一8位整型数组的子数组构造得到的字符。 不推荐使用该方法。
String(byte[], int, int, String)
用指定的字符编码方式转换指定的字节子数组生成一个新的 String。
String(byte[], String)
用指定的字符编码方式转换指定的字节数组生成一个新的String 。
String(char[])
分配一个新 String ，它包含有字符数组参数中的字符序列。
String(char[], int, int)
分配一个新 String ，它包含有字符数组参数的一个子数组中的字符序列。
String(String)
分配一个新 String ，它和字符串参数中有相同的字符序列。
String(StringBuffer)
分配一个新 String ，它包含有当前字符串缓冲区参数中的字符序列。
--------------------------------------------------------------------------------
方法索引
charAt(int)
返回指定索引处的字符。
compareTo(String)
按词典顺序比较两个字符串。
concat(String)
将一个指定的字符串添加到该字符串尾部。
copyValueOf(char[])
返回一个等价于指定字符数组的 String 。
copyValueOf(char[], int, int)
返回一个等价于指定字符数组的 String 。
endsWith(String)
测试该字符串尾部是否是指定的后缀。
equals(Object)
比较该字符串和指定的对象。
equalsIgnoreCase(String)
比较该 String 和另一个对象。
getBytes()
按照平台缺省的字符编码方式把该 String 转换成字节，并把结果存到一新的字节数组中。
getBytes(int, int, byte[], int)
从该字符串中拷贝字符到目的字节数组中。 不推荐使用该方法。
getBytes(String)
按照指定的字符编码方式把该 String 转换成字节，并把结果存到一新的字节数组中。
getChars(int, int, char[], int)
从该字符串中拷贝字符到目的字符数组中。
hashCode()
返回该字符串的哈希码。
indexOf(int)
返回在该字符串中指定字符第一次出现处的索引。
indexOf(int, int)
在指定索引处开始查找，返回在该字符串中指定字符第一次出现处的索引。
indexOf(String)
返回在该字符串中指定的子字符串第一次出现处的索引。
indexOf(String, int)
在指定索引处开始查找，返回在该字符串中指定的子字符串第一次出现处的索引。
intern()
返回该字符串对象的规范表示法。
lastIndexOf(int)
返回在该字符串中指定字符最后一次出现处的索引。
lastIndexOf(int, int)
在指定索引处开始查找，返回在该字符串中指定字符最后一次出现处的索引。
lastIndexOf(String)
返回在该字符串中指定子字符串在最左端出现处的索引。
lastIndexOf(String, int)
返回在该字符串中指定子字符串最后一次出现处的索引。
length()
返回该字符串的长度。
regionMatches(boolean, int, String, int, int)
测试两个字符串区域是否相等。
regionMatches(int, String, int, int)
测试两个字符串区域是否相等。
replace(char, char)
返回一个新字符串，所得结果是把该字符串中所有的 oldChar 替换成 newChar 。
startsWith(String)
测试该字符串开头是否是指定的前缀。
startsWith(String, int)
测试该字符串开头是否是指定的前缀。
substring(int)
返回是该字符串子串的新字符串。
substring(int, int)
返回是该字符串子串的新字符串。
toCharArray()
把该字符串转换成一新的字符数组。
toLowerCase()
把该 String 转换为小写。
toLowerCase(Locale)
用给定的位置规则把该 String 中的所有的字符转换为小写。
toString()
返回该对象 (已经是一个字符串!) 自身。
toUpperCase()
把该 String 转换为大写。
toUpperCase(Locale)
用给定的位置规则把该 String 中的所有的字符转换为大写。
trim()
删除该字符串两端的空格。
valueOf(boolean)
返回 boolean 参数的字符串表示。
valueOf(char)
返回 char * 参数的字符串表示。
valueOf(char[])
返回 char 数组参数的字符串表示。
valueOf(char[], int, int)
返回 char 数组参数的一个指定子数组的字符串表示。
valueOf(double)
返回 double 参数的字符串表示。
valueOf(float)
返回 float 参数的字符串表示。
valueOf(int)
返回 int 参数的字符串表示。
valueOf(long)
返回 long 参数的字符串表示。
valueOf(Object)
返回 Object 参数的字符串表示。
--------------------------------------------------------------------------------
构造子
String
public String()
分配一个新的不含有字符的 String 。
String
public String(String value)
分配一个新 String ，它包含有与字符串参数相同的字符序列。
参数：
value - 一个 String.
String
public String(char value[])
分配一个新 String ，它包含有当前字符数组参数中的字符。
参数：
value - 字符串的初始值
String
public String(char value[],
int offset,
int count)
分配一个新 String ，它包含字符数组参数的一个子数组的字符。 offset 参数是子数组中第一个字符的索引， count 参数指定了子数组的长度。
参数：
value - 源字符数组。
offset - 初始的偏移值。
count - 长度。
抛出： StringIndexOutOfBoundsException
如果 offset 和 count 参数超出了 value 数组的边界。
String
public String(byte ascii[],
int hibyte,
int offset,
int count)
注意：不推荐使用 String() 方法。 该方法不适当地把字节转换成字符。同 JDK 1.1 类似，完成此操作的首选方法是采用 String 构造函数，它携带一个字符-编码方式名，或平台的缺省编码方式名作参数。
从一个8位整型数组的子数组生成一新的 String 。
offset 参数是子数组中第一个字节处的索引， count 参数指定了子数组的长度。
子数组中的每个 byte 如上面方法描述的那样被转换为一个 char 。
参数：
ascii - 要转换为字符的字节。
hibyte - 每个16-bit Unicode 字符中的头 8 位。
offset - 初始的的偏移量。
count - 长度。
抛出： StringIndexOutOfBoundsException
如果 offset 或 count 参数无效。
参见:
String, String, String, String, String
String
public String(byte ascii[],
int hibyte)
注意：不推荐使用 String() 方法。 该方法不适当地把字节转换成字符。同 JDK 1.1 类似，完成此操作的首选方法是采用 String 构造函数，它携带一个字符-编码方式名，或平台的缺省编码名作参数。
从一个 8-bit 整型数组生成一新的 String 。 结果字符串中的每个字符 c 是由字节数组中的对应部分 b 构造的。如：
c == (char)(((hibyte & 0xff) << 8)
| (b & 0xff))
参数：
ascii - 要转换为字符的字节。
hibyte - 每个 16-bit Unicode 字符中的头 8 位。
参见:
String, String, String, String
String
public String(byte bytes[],
int offset,
int length,
String enc) throws UnsupportedEncodingException
用指定的字符编码方式转换指定的字节子数组生成一个新的 String 。 新 String 的长度是一个编码函数，因此可能不等于子数组的长度。
参数：
bytes - 要转换为字符的字节。
offset - 要转换的第一个字节的索引。
length - 要转换的字节数。
enc - 字符编码方式的名称。
抛出： UnsupportedEncodingException
如果不支持该编码方式
String
public String(byte bytes[],
String enc) throws UnsupportedEncodingException
用指定的字符编码方式转换指定的字节数组生成一新的 String 。 新 String 的长度是一个编码函数，因此可能不等于字节数组的长度。
参数：
bytes - 要转换为字符的字节。
enc - 一个字符-编码方式名
抛出： UnsupportedEncodingException
如果不支持该编码方式
String
public String(byte bytes[],
int offset,
int length)
用平台缺省的字符编码方式转换指定的字节子数组生成一个新的 String 。 新 String 的长度是一个编码函数，因此可能不等于子数组的长度。
参数：
bytes - 要转换为字符的字节。
offset - 要转换的第一个字节的索引。
length - 要转换的字节数。
String
public String(byte bytes[])
用平台缺省的字符编码方式转换指定的字节数组生成一新的 String 。 新 String 的长度是一个编码函数，因此可能不等于字节数组的长度。
参数：
bytes - 要转换为字符的字节。
String
public String(StringBuffer buffer)
分配一个新 String ，它包含有当前字符串缓冲区参数中的字符序列。
参数：
buffer - 一个 StringBuffer.
--------------------------------------------------------------------------------
方法
length
public int length()
返回该字符串的长度。 长度等于字符串中的 16-bit 的 Unicode 字符的数量。
返回:
该对象代表的字符序列的长度。
charAt
public char charAt(int index)
返回指定索引处的字符。 索引范围 从 0 到 length() - 1 。
参数：
index - 字符的索引。
返回:
该字符串指定位置的字符。 第一个字符在索引 0 处。
抛出： StringIndexOutOfBoundsException
如果索引超出了范围。
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 - 目标数组中的开始偏移量。
抛出： StringIndexOutOfBoundsException
如果 srcBegin 或 srcEnd 超出了范围，或如果 srcBegin 大于 srcEnd 。
getBytes
public void getBytes(int srcBegin,
int srcEnd,
byte dst[],
int dstBegin)
注意：不推荐使用 getBytes() 方法。 该方法不适当地把字符转换成字节。同 JDK 1.1 类似，完成此操作的首选方法是采用 getBytes(String enc) 方法， 它使用一个字符-编码方式名作参数，或使用 getBytes() 方法，它使用平台的缺省编码方式。
从该字符串拷贝字符到目的字节数组中。 每个字节接收对应字符的低8位。
第一个要复制的字符在索引 srcBegin 处； 最后一个要复制的字符在索引 srcEnd-1 处。要复制的字符总数是 srcEnd-srcBegin 。字符被转换成字节复制到 dst 子数组。它开始于索引 dstBegin ，结束于索引：
dstbegin + (srcEnd-srcBegin) - 1
参数：
srcBegin - 要复制的字符串中第一个字符的索引。
srcEnd - 要复制的字符串中最后一个字符的索引。
dst - 目标数组。
dstBegin - 目标数组中的开始偏移量。
抛出： StringIndexOutOfBoundsException
如果 srcBegin 或 srcEnd 超出了范围，或如果 srcBegin 大于 srcEnd 。
getBytes
public byte[] getBytes(String enc) throws UnsupportedEncodingException
按照指定的字符编码方式把该 String转换为字节，结果存到一个新的字节数组中。
参数：
enc - 一个字符-编码名称
返回:
结果的字节数组
抛出： UnsupportedEncodingException
如果不支持该编码方式
getBytes
public byte[] getBytes()
按照平台缺省的字符编码方式把该 String 转换成字节，并把结果存到一新的字节数组中。
返回:
作为结果的字节数组
equals
public boolean equals(Object anObject)
比较该字符串和指定的对象。当且仅当参数不为 null ，且是一个 String 对象，它表示的字符序列与此对象相同时结果为 true 。
参数：
anObject - 要同该 String 作比较的对象。
返回:
如果和 String 相等则为 true ；否则为 false 。
覆盖:
类 Object 中的 equals
参见:
compareTo, equalsIgnoreCase
equalsIgnoreCase
public boolean equalsIgnoreCase(String anotherString)
比较该字符串和另一个对象。 当且仅当参数不为 null ，且是一个String 对象，它所表示的字符序列在大小写被忽略时与此对象相同，则结果为 true 。
如果至少满足以下条件之一，则两个字符在忽略大小写时被认为是相等的：
两个字符是相同的 (通过 == 运算符比较)。
对每个字符应用方法 Character.toUppercase ，产生的结果相同。
对每个字符应用方法 Character.toLowercase ，产生的结果相同。
如果两个字符序列有相同的长度且对应的字符在忽略大小写时相同，，则两个字符序列被认为是相等的。
参数：
anotherString - 要同该 String 相比较的 String 。
返回:
忽略大小写时，如果和 String 相等，则为 true ；否则为 false 。
参见：
toLowerCase, toUpperCase
compareTo
public int compareTo(String anotherString)
按词典顺序比较两个字符串。 比较的基础是字符串中每个字符的 Unicode 值。
参数：
anotherString - 要比较的 String 。
返回:
若参数字符串等于该字符串，则返回 0 ；若该字符串按词典顺序小于参数字符串则返回值小于 0 ；若该字符串按词典顺序大于参数字符串则返回值大于 0 。
regionMatches
public boolean regionMatches(int toffset,
String other,
int ooffset,
int len)
测试两个字符串区域是否相等。
如果 toffset 或 ooffset 是负的，或如果 toffset+length 大于该字符串的长度， 或 ooffset+length 大于参数字符串的长度，那么该方法返回 false 。
参数：
toffset - 该字符串中子区域的开始偏移量。
other - 字符串参数。
ooffset - 参数字符串中子区域的开始偏移量。
len - 要比较的字符数。
返回:
若该字符串的指定子区域精确匹配参数字符串中的指定子区域则返回 true ，否则返回 false 。
regionMatches
public boolean regionMatches(boolean ignoreCase,
int toffset,
String other,
int ooffset,
int len)
测试两个字符串区域是否相等。
如果 toffset 或 ooffset 是负的，或如果 toffset+length 大于该字符串的长度， 或 ooffset+length 大于参数字符串的长度，那么该方法返回 false 。
参数：
ignoreCase - 如果为 true ，则比较时忽略大小写。
toffset - 该字符串中子区域的开始偏移量。
other - 字符串参数。
ooffset - 参数字符串中子区域的开始偏移量。
len - 要比较的字符数。
返回:
若该字符串的指定子区域匹配参数字符串中的指定子区域则返回 true ，否则返回 false 。 匹配是否精确或是否大小写敏感依赖于 ignoreCase 参数。
startsWith
public boolean startsWith(String prefix,
int toffset)
测试该字符串是否是以指定的前缀开头。
参数：
prefix - 前缀。
toffset - 在字符串中查找的起始点。
返回:
若参数表示的字符序列是该对象开始于索引 toffset 处的子字符串前缀则返回 true ，否则返回 false 。
startsWith
public boolean startsWith(String prefix)
测试该字符串是否以指定的前缀开始。
参数：
prefix - 前缀。
返回:
若参数表示的字符序列是该字符串序列的前缀则返回 true ，否则返回 false 。
endsWith
public boolean endsWith(String suffix)
测试该字符串是否以指定的字符串作后缀。
参数：
suffix - 后缀。
返回:
若参数表示的字符序列是该对象字符序列的后缀则返回 true ，否则返回 false 。
hashCode
public int hashCode()
返回该字符串的哈希码。
返回:
该对象的哈希码值。
覆盖:
类 Object 中的 hashCode
indexOf
public int indexOf(int ch)
返回在该字符串中指定字符第一次出现处的索引。
参数：
ch - 一个字符。
返回:
对象表示的字符序列中该字符第一次出现处的索引，若字符没有出现则返回 -1 。
indexOf
public int indexOf(int ch,
int fromIndex)
从指定的索引开始查找，返回在该字符串中指定字符第一次出现处的索引。
参数：
ch - 一个字符。
fromIndex - 开始查找位置的索引。
返回:
在该对象表示的字符序列中大于或等于 fromIndex 字符的字符第一次出现处的索引，若字符没有出现则返回 -1 。
lastIndexOf
public int lastIndexOf(int ch)
返回指定字符在该字符串中最后一次出现处的索引。查找顺序是从最后一个字符开始回退查找。
参数：
ch - 一个字符。
返回:
对象表示的字符序列中该字符最后一次出现处的索引，若字符没有出现则返回 -1 。
lastIndexOf
public int lastIndexOf(int ch,
int fromIndex)
返回指定字符在该字符串中最后一次出现处的索引，在指定索引处开始进行反向查找。
参数：
ch - 一个字符。
fromIndex - 开始查找位置的索引。
返回:
该对象表示的字符序列中小于或等于 fromIndex 字符的字符最后一次出现处的下标，若字符在该位置之前没有出现过则返回 -1 。
indexOf
public int indexOf(String str)
返回指定子字符串在该字符串中第一次出现处的索引。
参数：
str - 子字符串。
返回:
若字符串参数作为该对象的子串出现，则返回第一个这样的子串第一个字符的索引，如果它没有作为一个子串出现则返回 -1 。
indexOf
public int indexOf(String str,
int fromIndex)
从指定索引位置处开始查找，返回指定子字符串在该字符串中第一次出现处的索引。
参数：
str - 要搜索的子串。
fromIndex - 开始查找位置的索引。
返回:
如果字符串参数作为该对象起始位置不小于 fromIndex 的子串出现时，则返回第一个这样的子串首字符的索引。 若它没有作为从 fromIndex 开始或靠后位置开始的子串出现，则返回 -1 。
lastIndexOf
public int lastIndexOf(String str)
返回指定子字符串在该字符串中最右端出现处的索引。最右端的空字符串 "" 被认为出现在下标值为 this.length() 位置。
参数：
str - 要搜索的子串。
返回:
如果字符串参数作为该对象的一个子串出现了一次或更多次，则返回最后一个这样的子串第一个字符的索引。若没有作为一个子串出现则返回 -1 。
lastIndexOf
public int lastIndexOf(String str,
int fromIndex)
返回在指定子字符串在该字符串中最后一次出现处的索引。返回的索引指示了子串的开始位置，并且它必须等于或小于 fromIndex 。
参数：
str - 要搜索的子串。
fromIndex - 开始查找位置的索引。
返回:
若字符串参数作为该对象起始索引不大于 fromIndex 的子串出现了一次或多次，则返回最后一个这样的子串第一个字符的索引。若它没有作为从 fromIndex 开始或靠前位置开始的子串出现，则返回 -1 。
substring
public String substring(int beginIndex)
返回是该字符串子串的新字符串。子串开始于指定的位置并且扩展到该字符串结尾。
参数：
beginIndex - 开始位置索引(包括它本身在内)。
返回:
指定的子串。
抛出： StringIndexOutOfBoundsException
如果 beginIndex 超出了范围。
substring
public String substring(int beginIndex,
int endIndex)
返回是该字符串子串的新字符串。 子串开始于指定的 beginIndex ，且扩展到索引为 endIndex - 1 的位置。
参数：
beginIndex - 开始索引(包括它本身在内)。
]endIndex - 终止索引(不包括本身)。
返回:
指定的子串。
抛出： StringIndexOutOfBoundsException
如果 beginIndex 或 endIndex 超出了范围。
concat
public String concat(String str)
将一个指定的字符串添加到该字符串尾部。
如果参数长度是 0 ，则返回该对象。
参数：
str - 要连接到该 String 尾部的 String 。
返回:
一个表示两字符串连接结果的字符串 。
replace
public String replace(char oldChar,
char newChar)
返回一个新字符串，所得结果是把该字符串中所有的 oldChar 替换成 newChar 。
如果字符 oldChar 没有出现在该对象表示的字符串序列中，则返回该字符串。
参数：
oldChar - 旧字符。
newChar - 新字符。
返回:
一个字符串，由该字符串中出现的每个 oldChar 被替换为 newChar 得到。
toLowerCase
public String toLowerCase(Locale locale)
用给定的位置规则把该 String 中所有的字符转换为小写。
参数：
locale - 对该位置做大小写变换
返回:
被转换成小写的字符串。
参见:
toLowerCase, toUpperCase
toLowerCase
public String toLowerCase()
转换该 String 为小写。
按照 Character 定义的 toLowerCase 方法，如果字符串中没有应该被转换的字符，则返回原始字符串。
否则，将分配一个新字符串，它的长度等于该字符串，并且源字符串中每个该进行小写转换的字符都被转换成等价的小写字符。
返回:
被转换成小写的字符串。
参见:
toLowerCase, toUpperCase
toUpperCase
public String toUpperCase(Locale locale)
用给定的位置规则把该 String 中的所有字符转换为大写。
参数：
locale - 对该位置做大小写变换
返回:
被转换成大写的字符串。
参见:
toUpperCase, toLowerCase
toUpperCase
public String toUpperCase()
转换该 String 为大写。
按照 Character 定义的 toUpperCase 方法，如果在字符串中没有应该进行大写转换的字符，则返回原始字符串。
否则，将分配一个新字符串，它的长度等于该字符串，并且源字符串中每个应该大写转换的字符都被转换成等价的大写字符。
返回:
被转换成大写的字符串。
参见:
toUpperCase, toLowerCase
trim
public String trim()
删除该字符串两端的空格。
所有小于或等于 '\u0020' (空格字符)的字符都被认为是空格。
返回:
头尾两端的空格都被删掉的字符串。
toString
public String toString()
该对象(已经是一个字符串!)本身被返回。
返回:
字符串本身。
覆盖:
类 Object 中的 toString
toCharArray
public char[] toCharArray()
把该字符串转换成一个新的字符数组。
返回:
一个新分配的字符数组，其长度就是该字符串的长度，内容初始化为该字符串表示的字符序列。
valueOf
public static String valueOf(Object obj)
返回 Object 参数的字符串表示。
参数：
obj - 一个 Object.
返回:
如果参数是 null ，则返回一个等于 "null" 的字符串；否则返回 obj.toString() 。
参见:
toString
valueOf
public static String valueOf(char data[])
返回 char 数组参数的字符串表示。
参数：
data - 一个 char 数组。
返回:
一个新分配的字符串，表示包含在字符数组参数中的相同字符序列。
valueOf
public static String valueOf(char data[],
int offset,
int count)
返回代表 char 数组参数一个指定子数组的字符串。
offset 参数是子数组中第一个字符的索引。 count 参数指定了子数组的长度。
参数：
data - 字符数组。
offset - String 的起始偏移量。
count - String 字符序列的长度。
返回:
一个新分配的字符串，表示包含在字符数组参数子数组中的相同字符序列。
copyValueOf
public static String copyValueOf(char data[],
int offset,
int count)
返回一个等价于指定字符数组的 String 。 它生成一个新数组并且向它内部复制字符。
参数：
data - 字符数组。
offset - 子数组的起始偏移量。
count - 子数组的长度。
返回:
一个 String ，包含了字符数组指定子数组中的字符。
copyValueOf
public static String copyValueOf(char data[])
返回一个等价于指定字符数组的 String 。 它生成一个新数组并且向它内部复制字符。
参数：
data - 字符数组。
返回:
一个 String ，包含了字符数组中的字符。
valueOf
public static String valueOf(boolean b)
返回 boolean 参数的字符串表示。
参数：
b - 一个 boolean 数。
返回:
如果参数是 true ，返回一个等于 "true" 的字符串；否则返回一个等于 "false" 的字符串。
valueOf
public static String valueOf(char c)
返回 char * 参数的字符串表示。
参数：
c - 一个 char 型量。
返回:
一个长度为 1 的新字符串，它仅有的字符是参数 c 。
valueOf
public static String valueOf(int i)
返回 int 参数的字符串表示。
返回内容和参数的 Integer.toString 方法返回的值相同。
参数：
i - 一个 int 量。
返回:
一个新分配的字符串，包含了 int 参数的字符串表示。
参见:
toString
valueOf
public static String valueOf(long l)
返回代表 long 参数的字符串。
返回内容和参数的 Long.toString 方法返回的值相同。
参数：
l - 一个 long 型量。
返回:
一个新分配的字符串，包含了 long 参数的字符串表示。
参见:
toString
valueOf
public static String valueOf(float f)
返回 float 参数的字符串表示。
返回的内容和参数的 Float.toString 方法返回的值相同。
参数：
f - 一个 float 型量。
返回:
一个新分配的字符串，包含了 float 参数的字符串表示。
参见:
toString
valueOf
public static String valueOf(double d)
返回 double 参数的字符串表示。
返回的内容和参数的 Double.toString 方法返回的值相同。
参数：
d - 一个 double 型量。
返回:
一个新分配的字符串，包含了 double 参数的字符串表示。
参见:
toString
intern
public native String intern()
返回一个字符串对象的规范表示法。
如果 s 和 t 是 s.equals(t) 类型的字符串，那就保证了
s.intern() == t.intern().
返回:
一个同该字符串内容相同的字符串，但是来自于唯一字符串的缓冲池
