String

CASE_INSENSITIVE_ORDER

Comparator<String> CASE_INSENSITIVE_ORDER

一个比较器，用compareToIgnoreCase命令String对象。 这个比较器是可串行化的。

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

String

String ()

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

String

String (String original)

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

String

String (char[] value)

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

String

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

分配包含字符数组参数的子数组中的字符的新的String 。 offset参数是子count的第一个字符的索引，而count参数指定子count的长度。 子数组的内容被复制; 字符数组的后续修改不会影响新创建的字符串。

String

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

分配一个新的String ，其中包含Unicode code point数组参数的子阵列中的字符 。 offset参数是子count的第一个代码点的索引，而count参数指定子count的长度。 子阵列的内容转换为char s; 随后对int数组进行的修改不会影响新创建的字符串。

String

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

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

分配由8位整数值数组的子阵列构造的新的 String 。

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

子 byte中的每个 byte按照上述方法中的指定转换为 char 。

String

String (byte[] ascii, 
                int hibyte)

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

分配一个新的String其中包含由8位整数值数组String的字符。 结果字符串中的每个字符c都是由字节数组中的对应组件b构造的，因此：

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

String

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

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

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

String

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

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

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

String

String (byte[] bytes, 
                String charsetName)

构造一个新的String由指定用指定的字节的数组解码charset 。 新的String的长度是字符集的函数，因此可能不等于字节数组的长度。

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

String

String (byte[] bytes, 
                Charset charset)

构造一个新的String由指定用指定的字节的数组解码charset 。 新的String的长度是字符集的函数，因此可能不等于字节数组的长度。

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

String

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

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

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

String

String (byte[] bytes)

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

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

String

String (StringBuffer buffer)

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

String

String (StringBuilder builder)

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

提供此构造函数可轻松迁移到StringBuilder 。 通过toString方法从字符串构建器获取字符串可能运行得更快，通常是首选。

charAt

char charAt (int index)

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

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

codePointAt

int codePointAt (int index)

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

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

codePointBefore

int codePointBefore (int index)

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

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

codePointCount

int codePointCount (int beginIndex, 
                int endIndex)

返回此String的指定文本范围内的Unicode代码点数。 文本范围始于指定beginIndex并延伸到char在索引endIndex - 1 。 因此，文本范围的长度（ char s）为endIndex-beginIndex 。 文本范围内的不配对代理每个计为一个代码点。

compareTo

int compareTo (String anotherString)

按字母顺序比较两个字符串。 该比较基于字符串中每个字符的Unicode值。 由此String对象表示的字符序列按字典顺序与参数字符串表示的字符序列进行比较。 如果这个String对象按照字典顺序String在参数字符串之前，那么结果是一个负整数。 如果这个String对象按照字典顺序跟随参数字符串，那么结果是一个正整数。 如果字符串相等，结果为零; compareTo正好在equals(Object)方法返回0时返回true 。

这是词典排序的定义。 如果两个字符串不同，那么它们在某个索引处具有不同的字符，这是两个字符串的有效索引，或者它们的长度不同，或者两者都有。 如果它们在一个或多个索引位置具有不同的字符，则令k为最小的这样的索引; 那么位置k处的字符具有较小值的字符串，通过使用<运算符确定，按字典顺序排列在另一个字符串之前。 在这种情况下， compareTo返回两个字符串中位置为k的两个字符值的k - 即值：

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

 this.length()-anotherString.length()
 

compareToIgnoreCase

int compareToIgnoreCase (String str)

按字母顺序比较两个字符串，忽略大小写差异。 此方法返回一个整数，其符号为调用compareTo的字符串的标准化版本，其中通过在每个字符上调用Character.toLowerCase(Character.toUpperCase(character))来消除案例差异。

请注意，此方法不场所考虑，并会导致特定的语言环境不满意的排序。 java.text包提供collators以允许区域设置敏感的排序。

concat

String concat (String str)

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

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

例子：

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

contains

boolean contains (CharSequence s)

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

contentEquals

boolean contentEquals (StringBuffer sb)

将此字符串与指定的StringBuffer 。 其结果是true ，如果，如果这仅String表示字符作为指定的相同序列StringBuffer 。

contentEquals

boolean contentEquals (CharSequence cs)

将该字符串与指定的CharSequence 。 当且仅当此String表示与指定序列相同的char值序列时，结果为true 。

copyValueOf

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

返回一个字符串，它表示指定数组中的字符序列。

copyValueOf

String copyValueOf (char[] data)

返回一个字符串，它表示指定数组中的字符序列。

endsWith

boolean endsWith (String suffix)

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

equals

boolean equals (Object anObject)

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

equalsIgnoreCase

boolean equalsIgnoreCase (String anotherString)

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

如果至少存在以下一种情况，则两个字符 c1和 c2被视为相同的忽略情况：

• The two characters are the same (as compared by the == operator)
• Applying the method toUpperCase(char) to each character produces the same result
• Applying the method toLowerCase(char) to each character produces the same result

format

String format (Locale l, 
                String format, 
                Object... args)

使用指定的区域设置，格式字符串和参数返回格式化的字符串。

format

String format (String format, 
                Object... args)

使用指定的格式字符串和参数返回格式化的字符串。

始终使用的区域设置是由 Locale.getDefault()返回的区域设置。

getBytes

byte[] getBytes (String charsetName)

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

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

getBytes

byte[] getBytes ()

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

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

getBytes

byte[] getBytes (Charset charset)

使用给定的 charset将此 String编码为一个字节序列，将结果存储到新的字节数组中。

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

getBytes

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

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

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

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

     dstbegin + (srcEnd-srcBegin) - 1
 

getChars

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

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

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

     dstbegin + (srcEnd-srcBegin) - 1
 

hashCode

int hashCode ()

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

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

indexOf

int indexOf (int ch, 
                int fromIndex)

返回指定字符首次出现的此字符串内的索引，从指定索引处开始搜索。

如果与值的字符ch在此表示的字符序列发生String的索引不小于在对象fromIndex ，则返回第一个这样的匹配项的索引。 对于0到0xFFFF（含）范围内的值ch ，这是最小值k ，以便：

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

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

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

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

indexOf

int indexOf (String str)

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

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

 this.startsWith(str, k)
 

indexOf

int indexOf (int ch)

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

 this.charAt(k) == ch
 

 this.codePointAt(k) == ch
 

indexOf

int indexOf (String str, 
                int fromIndex)

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

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

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

intern

String intern ()

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

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

当调用实习生方法中，如果池已包含一个字符串等于该String如由所确定的对象equals(Object)方法，然后从池中字符串被返回。 否则，将此String对象添加到池中，并返回对此String对象的引用。

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

所有的文字字符串和字符串值的常量表达式都被禁用。 字符串文字在The Java™ Language Specification的第3.10.5节中定义。

isEmpty

boolean isEmpty ()

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

lastIndexOf

int lastIndexOf (int ch)

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

 this.charAt(k) == ch
 

 this.codePointAt(k) == ch
 

lastIndexOf

int lastIndexOf (String str, 
                int fromIndex)

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

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

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

lastIndexOf

int lastIndexOf (String str)

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

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

 this.startsWith(str, k)
 

lastIndexOf

int lastIndexOf (int ch, 
                int fromIndex)

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

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

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

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

length

int length ()

返回此字符串的长度。 长度等于字符串中的数字Unicode code units 。

matches

boolean matches (String regex)

告诉这个字符串是否与给定的 regular expression匹配。

格式 str .matches( 正则表达式 )的这种方法的调用产生与 表达式完全相同的结果

Pattern.matches( regex , str )

offsetByCodePoints

int offsetByCodePoints (int index, 
                int codePointOffset)

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

regionMatches

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

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

将此String对象的子字符串与参数other的子字符串进行比较 。 如果这些子字符串表示相同的字符序列，则结果为true ，当且仅当ignoreCase为真时，忽略大小写。 该待比较的String对象的子串从索引toffset开始，长度为len 。 待比较的子串other从索引ooffset开始，长度为len 。 结果是false当且仅当以下至少一个条件成立：

• toffset is negative.
• ooffset is negative.
• toffset+len is greater than the length of this String object.
• ooffset+len is greater than the length of the other argument.
• ignoreCase is false and there is some nonnegative integer k less than len such that:

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

• ignoreCase is true and there is some nonnegative integer k less than len such that:

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

  and:

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

regionMatches

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

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

此String对象的子字符串与参数other的子字符串进行比较。 如果这些子字符串表示相同的字符序列，则结果为真。 此String要比较的对象的子串从索引toffset开始，长度为len 。 其他待比较的子串从索引ooffset开始，长度为len 。 结果是false当且仅当以下至少一个条件成立：

• toffset is negative.
• ooffset is negative.
• toffset+len is greater than the length of this String object.
• ooffset+len is greater than the length of the other argument.
• There is some nonnegative integer k less than len such that: this.charAt(toffset+k) != other.charAt(ooffset+k)

replace

String replace (CharSequence target, 
                CharSequence replacement)

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

replace

String replace (char oldChar, 
                char newChar)

返回从更换所有出现而产生的新的字符串 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)
 

replaceAll

String replaceAll (String regex, 
                String replacement)

用给定的替换替换与给定的 regular expression相匹配的该字符串的每个子字符串。

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

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

请注意替换字符串中的反斜杠（ \ ）和美元符号（ $ ）可能会导致结果与将它视为字面替换字符串时的结果不同; 见Matcher.replaceAll 。 如果需要，使用quoteReplacement(String)来抑制这些字符的特殊含义。

replaceFirst

String replaceFirst (String regex, 
                String replacement)

用给定的替换替换此字符串的第一个子字符串，该字符串与给定的 regular expression匹配。

格式 str .replaceFirst( regex , repl )的这种方法的调用将产生与表达式完全相同的结果

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

请注意替换字符串中的反斜杠（ \ ）和美元符号（ $ ）可能会导致结果与将它视为字面替换字符串时的结果不同; 见replaceFirst(String) 。 如果需要，使用quoteReplacement(String)来抑制这些字符的特殊含义。

split

String[] split (String regex, 
                int limit)

将该字符串拆分为给定的 regular expression的匹配。

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

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

例如，字符串 "boo:and:foo"通过这些参数产生以下结果：

Regex	Limit	Result
:	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( 正则表达式 , n )产生与表达式相同的结果

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

split

String[] split (String regex)

将该字符串拆分为给定的 regular expression 。

此方法的工作原理与通过调用具有给定表达式和极限参数为零的双参数split方法一样。 尾随的空字符串因此不包含在结果数组中。

例如，字符串 "boo:and:foo"可用以下表达式得出以下结果：

Regex	Result
:	{ "boo", "and", "foo" }
o	{ "b", "", ":and:f" }

startsWith

boolean startsWith (String prefix)

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

startsWith

boolean startsWith (String prefix, 
                int toffset)

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

          this.substring(toffset).startsWith(prefix)
          

subSequence

CharSequence subSequence (int beginIndex, 
                int endIndex)

返回一个新的字符序列，该序列是该序列的子序列。

这种形式的方法的调用

 str.subSequence(begin, end)

 str.substring(begin, end)

substring

String substring (int beginIndex, 
                int endIndex)

返回一个新字符串，该字符串是此字符串的一个子字符串。 子字符串从指定的beginIndex开始，并延伸到索引号为endIndex - 1的字符。 因此子字符串的长度是endIndex-beginIndex 。

例子：

 "hamburger".substring(4, 8) returns "urge"
 "smiles".substring(1, 5) returns "mile"
 

substring

String substring (int beginIndex)

返回一个新字符串，该字符串是此字符串的一个子字符串。 子字符串以指定索引处的字符开头，并延伸到此字符串的末尾。

例子：

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

toCharArray

char[] toCharArray ()

将此字符串转换为新的字符数组。

toLowerCase

String toLowerCase ()

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

注意：此方法对区域设置非常敏感，如果用于旨在独立解释区域设置的字符串，则可能会产生意外的结果。 示例是编程语言标识符，协议密钥和HTML标签。 例如， "TITLE".toLowerCase()在土耳其语言环境返回"t\u0131tle" ，其中“\ u0131”是拉丁小写字母无点我的性格。 要获得区域设置不敏感字符串的正确结果，请使用toLowerCase(Locale.ENGLISH) 。

toLowerCase

String toLowerCase (Locale locale)

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

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

Language Code of Locale	Upper Case	Lower Case	描述
tr (Turkish)	\u0130	\u0069	capital letter I with dot above -> small letter i
tr (Turkish)	\u0049	\u0131	capital letter I -> small letter dotless i
(all)	French Fries	french fries	lowercased all chars in String
(all)			lowercased all chars in String

toString

String toString ()

这个对象（它已经是一个字符串！）本身返回。

toUpperCase

String toUpperCase (Locale locale)

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

区域设置敏感和1：M大小写映射的示例如下表所示。

toUpperCase

String toUpperCase ()

使用默认语言环境的规则将此String所有字符转换为大写。 这种方法相当于toUpperCase(Locale.getDefault()) 。

注意：此方法对区域设置非常敏感，如果用于旨在独立解释区域设置的字符串，则可能会产生意外的结果。 示例是编程语言标识符，协议密钥和HTML标签。 例如， "title".toUpperCase()在土耳其语言环境返回"T\u0130TLE" ，其中“\ u0130”是拉丁文大写字母我带点上述特征。 要获得区域设置不敏感字符串的正确结果，请使用toUpperCase(Locale.ENGLISH) 。

trim

String trim ()

返回字符串的副本，省略前导和尾随空白。

如果此 String对象表示一个空字符序列，或由该代表字符序列的第一个和最后一个字符 String对象都具有代码大于 '\u0020' （空格字符），则此参考 String被返回对象。

否则，如果字符串中不存在代码大于 '\u0020'的字符，则会创建并返回代表空字符串的新对象 String 。

否则，令k为代码大于'\u0020'的字符串中第一个字符的索引，并且让m为代码大于'\u0020'的字符串中最后一个字符的索引。 将创建一个新的String对象，该对象表示此字符串的子字符串，该字符串以索引k处的字符开头，并以索引m处的字符结尾 - 即this.substring(k, m+1)的结果。

该方法可用于从字符串的开始和结尾修剪空白（如上定义）。

valueOf

String valueOf (boolean b)

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

valueOf

String valueOf (double d)

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

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

valueOf

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

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

offset参数是子offset的第一个字符的索引。 count参数指定子阵列的长度。 子数组的内容被复制; 字符数组的后续修改不会影响新创建的字符串。

valueOf

String valueOf (float f)

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

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

valueOf

String valueOf (int i)

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

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

valueOf

String valueOf (char c)

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

valueOf

String valueOf (long l)

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

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

valueOf

String valueOf (Object obj)

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

valueOf

String valueOf (char[] data)

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