String (Java Platform SE 8 )

java.lang.Object
- java.lang.String

All Implemented Interfaces:

Serializable， CharSequence Comparable String >，<
```
public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence
```
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包括检查序列的单个字符的方法，用于比较字符串、搜索字符串，提取子字符串，并创建一个副本，一个与所有字符转化为大写或小写的字符串。例图是基于Unicode的标准版本Character类指定。

java语言提供了字符串串联运算符特殊支持（ + ），和其他对象转换为字符串。字符串连接是通过StringBuilder实施（或StringBuffer）类及其append方法。字符串的转换是通过方法toString实施，由Object和继承的所有类的java。在字符串连接和转换，更多信息见戈斯林，喜乐，和斯梯尔，第三版。

除非另有说明，通过null争论这类构造函数或方法会导致一个NullPointerException被。

一个String代表UTF-16格式，补充字符的代理项对代表一个字符串（更多信息请看在Character类的节Unicode Character Representations）。指标值是指char代码单元，所以补充字符用在String两位置。

的String类提供了用于处理Unicode代码点的方法（即字符），除了那些处理Unicode代码单元（即char值）。
Since:

JDK1.0

See Also:

Object.toString()， StringBuffer， StringBuilder， Charset， Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static Comparator<String>`	`CASE_INSENSITIVE_ORDER` 一个比较器，订单 `String`对象由 `compareToIgnoreCase`。

Constructor Summary

Constructors
Constructor and Description
`String()` 初始化新创建的 `String`对象，它代表了一个空字符序列。
`String(byte[] bytes)` 通过使用平台的默认字符集解码指定的字节数组构造了一个新的 `String`。
`String(byte[] bytes, Charset charset)` 通过使用指定的 charset解码指定的字节数组构造了一个新的 `String`。
`String(byte[] ascii, int hibyte)` 过时的。这种方法不正确地将字节转换为字符。作为 JDK 1.1，这样的首选方式是通过`String`构造函数带`Charset`，字符集名称，或使用平台的默认字符集。
`String(byte[] bytes, int offset, int length)` 构建了一种新的 `String`通过解码指定的字节数组使用平台的默认字符集。
`String(byte[] bytes, int offset, int length, Charset charset)` 构建了一种新的 `String`通过解码指定的字节数组使用指定的 charset。
`String(byte[] ascii, int hibyte, int offset, int count)` 过时的。这种方法不正确地将字节转换为字符。作为 JDK 1.1，这样的首选方式是通过`String`构造函数带`Charset`，字符集名称，或使用平台的默认字符集。
`String(byte[] bytes, int offset, int length, String charsetName)` 构建了一种新的 `String`通过解码指定的字节数组使用指定的字符集。
`String(byte[] bytes, String charsetName)` 通过使用指定的 charset解码指定的字节数组构造了一个新的 `String`。
`String(char[] value)` 分配一个新的 `String`，它代表了目前包含在字符数组参数字符序列。
`String(char[] value, int offset, int count)` 分配一个包含字符与字符数组数组参数的新 `String`。
`String(int[] codePoints, int offset, int count)` 分配一个包含字符子数组的数组参数的新 `String` Unicode code point。
`String(String original)` 初始化新创建的对象 `String`所以它代表相同的字符序列的说法；换句话说，新创建的字符串是一个副本的参数字符串。
`String(StringBuffer buffer)` 分配一个新的字符串，该字符串包含当前包含在字符串缓冲区中的字符的序列的字符串。
`String(StringBuilder builder)` 分配一个新的字符串，该字符串包含当前包含在字符串生成器参数中的字符的序列。

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`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)` 如果并且只有当此字符串包含指定的字符序列的字符串值，则返回真值。
`boolean`	`contentEquals(CharSequence cs)` 比较这个字符串来指定 `CharSequence`。
`boolean`	`contentEquals(StringBuffer sb)` 比较这个字符串来指定 `StringBuffer`。
`static String`	`copyValueOf(char[] data)` 相当于 `valueOf(char[])`。
`static String`	`copyValueOf(char[] data, int offset, int count)` 相当于 `valueOf(char[], int, int)`。
`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`编码成一个序列使用平台的默认字符集字节，结果存放到一个新的字节数组。
`byte[]`	`getBytes(Charset charset)` 这 `String`编码为一个字节序列使用给定的 charset，结果存放到一个新的字节数组。
`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()` 返回字符串对象的规范表示形式。
`boolean`	`isEmpty()` 返回 `true`如果，如果， `length()`是 `0`。
`static String`	`join(CharSequence delimiter, CharSequence... elements)` 返回一个由 `CharSequence elements`副本的新字符串连接在一起的一份指定的 `delimiter`。
`static String`	`join(CharSequence delimiter, Iterable<? extends CharSequence> elements)` 返回一个由 `CharSequence elements` `String`加入新的副本，连同一份指定的 `delimiter`。
`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)` 告诉是否这个字符串匹配给定 regular expression。
`int`	`offsetByCodePoints(int index, int codePointOffset)` 返回指数在这 `String`是从给定的 `codePointOffset`代码点 `index`偏移。
`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)` 每个子串替换该字符串的给予更换，给 regular expression比赛。
`String`	`replaceFirst(String regex, String replacement)` 代替这个字符串的替换，给 regular expression匹配第一个字符串。
`String[]`	`split(String regex)` 将此字符串在给定的 regular expression比赛。
`String[]`	`split(String regex, int limit)` 将此字符串在给定的 regular expression比赛。
`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)` 将所有的角色在这 `String`以较低的情况下使用给定的 `Locale`规则。
`String`	`toString()` 这个对象（这已经是一个字符串！）是自己回来了。
`String`	`toUpperCase()` 将所有的角色在这 `String`上使用的默认区域设置规则。
`String`	`toUpperCase(Locale locale)` 将所有的角色在这 `String`大写使用给定的 `Locale`规则。
`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`参数的字符串表示形式。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.CharSequence
chars, codePoints

Field Detail
- CASE_INSENSITIVE_ORDER
```
public static final Comparator<String> CASE_INSENSITIVE_ORDER
```
  一个比较器，订单 String对象由 compareToIgnoreCase。这是比较序列化。
  注意，这个比较不带区域的考虑，将导致某些地区理想的排序。java.text包提供的整合允许现场敏感的排序。
  
  Since:
  
  一点二
  
  See Also:
  
  Collator.compare(String, String)

Constructor Detail
- String
```
public String()
```
  初始化新创建的 String对象，它代表了一个空字符序列。请注意，使用此构造函数是不必要的，因为字符串是不可变的。
- String
```
public String(String original)
```
  初始化新创建的对象 String所以它代表相同的字符序列的说法；换句话说，新创建的字符串是一个副本的参数字符串。除非 original显式复制是必要的，使用这个构造函数是不必要的因为字符串是不可变的。
  
  Parameters:
  
  original - String
- String
```
public String(char[] value)
```
  分配一个新的 String，它代表了目前包含在字符数组参数字符序列。字符数组的内容被复制；字符数组的随后的修改不会影响到新创建的字符串。
  
  Parameters:
  
  value -字符串的初始值
- String
```
public String(char[] value,
              int offset,
              int count)
```
  分配一个包含字符与字符数组数组参数的新 String。的说法是 offset的子阵列的第一个字符的索引和 count参数指定的数组的长度。的子阵列的内容复制的字符数组；随后的修改不影响新创建的字符串。
  
  Parameters:
  
  value阵列是字源
  
  offset -初始偏移
  
  count -长度
  
  Throws:
  
  IndexOutOfBoundsException -如果 offset和 count参数指标的 value以外的字符数组的界限
- String
```
public String(int[] codePoints,
              int offset,
              int count)
```
  分配一个新的 String包含字符子数组的 Unicode code point数组参数。的说法是 offset的子阵第一个代码点的指数和 count参数指定的数组的长度。这阵的内容转换为 chars； int阵列的后续的修改不影响新创建的字符串。
  
  Parameters:
  
  codePoints阵列是Unicode代码点源
  
  offset -初始偏移
  
  count -长度
  
  Throws:
  
  IllegalArgumentException -如果任何无效的Unicode代码点发现 codePoints
  
  IndexOutOfBoundsException -如果 offset和 count参数指标的 codePoints以外的字符数组的界限
  
  Since:
  
  一点五
- String
```
@Deprecated
public String(byte[] ascii,
                          int hibyte,
                          int offset,
                          int count)
```
  过时的。这种方法不正确地将字节转换为字符。作为 JDK 1.1，这样的首选方式是通过String构造函数带Charset，字符集名称，或使用平台的默认字符集。
  
  分配一个新的 String由一位整数数组的数组。
  的说法是offset的子阵的第一个字节的索引，和count参数指定的数组的长度。
  
  在数组的每个byte转换为char按上述方法。
  
  Parameters:
  
  ascii -被转换为字符的字节
  
  hibyte -前8位每16位Unicode编码单元
  
  offset -初始偏移
  
  count -长度
  
  Throws:
  
  IndexOutOfBoundsException -如果 offset或 count参数无效
  
  See Also:
  
  String(byte[], int)， String(byte[], int, int, java.lang.String)， String(byte[], int, int, java.nio.charset.Charset)， String(byte[], int, int)， String(byte[], java.lang.String)， String(byte[], java.nio.charset.Charset)， String(byte[])
- String
```
@Deprecated
public String(byte[] ascii,
                          int hibyte)
```
  过时的。这种方法不正确地将字节转换为字符。作为 JDK 1.1，这样的首选方式是通过String构造函数带Charset，字符集名称，或使用平台的默认字符集。
  从8位整数的值构成的数组分配一个新的 String包含字符。每个字符的CIN结果字符串是由相应的组分B字节数组中的
```
     c == (char)(((hibyte & 0xff) << 8)
                         | (b & 0xff))
 
```
  这样：
  Parameters:
  
  ascii -被转换为字符的字节
  
  hibyte -前8位每16位Unicode编码单元
  
  See Also:
  
  String(byte[], int, int, java.lang.String)， String(byte[], int, int, java.nio.charset.Charset)， String(byte[], int, int)， String(byte[], java.lang.String)， String(byte[], java.nio.charset.Charset)， String(byte[])
- String
```
public String(byte[] bytes,
              int offset,
              int length,
              String charsetName)
       throws UnsupportedEncodingException
```
  构建了一种新的 String通过解码指定的字节数组使用指定的字符集。新的 String长度是一个字符集的功能，因此可能不相等的子阵列的长度。
  这个构造函数的行为时，给定的字节不适用于给定的字符集是不确定的。的CharsetDecoder班时应使用在解码过程中需要更多的控制。
  
  Parameters:
  
  bytes -解码为字符的字节
  
  offset -第一个要解码的字节的索引
  
  length -字节数解码
  
  charsetName -支持的 charset名称
  
  Throws:
  
  UnsupportedEncodingException -如果指定的字符集不支持
  
  IndexOutOfBoundsException -如果 offset和 length参数指标的 bytes以外的字符数组的界限
  
  Since:
  
  JDK1.1
- String
```
public String(byte[] bytes,
              int offset,
              int length,
              Charset charset)
```
  构建了一种新的 String通过解码指定的字节数组使用指定的 charset。新的 String长度是一个字符集的功能，因此可能不相等的子阵列的长度。
  这种方法总是会替换格式不正确的输入，无法映射的字符序列，该字符集的默认字符串替换。的CharsetDecoder班时应使用在解码过程中需要更多的控制。
  
  Parameters:
  
  bytes -解码为字符的字节
  
  offset -第一个要解码的字节的索引
  
  length -字节数解码
  
  charset - charset用来解码 bytes
  
  Throws:
  
  IndexOutOfBoundsException -如果 offset和 length参数指标的 bytes以外的字符数组的界限
  
  Since:
  
  一点六
- String
```
public String(byte[] bytes,
              String charsetName)
       throws UnsupportedEncodingException
```
  通过使用指定的 charset解码指定的字节数组构造了一个新的 String。新的 String长度是一个字符集的功能，因此可能不相等的字节数组的长度。
  这个构造函数的行为时，给定的字节不适用于给定的字符集是不确定的。的CharsetDecoder班时应使用在解码过程中需要更多的控制。
  
  Parameters:
  
  bytes -解码为字符的字节
  
  charsetName -支持的 charset名称
  
  Throws:
  
  UnsupportedEncodingException -如果指定的字符集不支持
  
  Since:
  
  JDK1.1
- String
```
public String(byte[] bytes,
              Charset charset)
```
  通过使用指定的 charset解码指定的字节数组构造了一个新的 String。新的 String长度是一个字符集的功能，因此可能不相等的字节数组的长度。
  这种方法总是会替换格式不正确的输入，无法映射的字符序列，该字符集的默认字符串替换。的CharsetDecoder班时应使用在解码过程中需要更多的控制。
  
  Parameters:
  
  bytes -解码为字符的字节
  
  charset - charset用来解码 bytes
  
  Since:
  
  一点六
- String
```
public String(byte[] bytes,
              int offset,
              int length)
```
  构建了一种新的 String通过解码指定的字节数组使用平台的默认字符集。新的 String长度是一个字符集的功能，因此可能不相等的子阵列的长度。
  这个构造函数的行为当给定字节无效的默认字符集是不确定的。的CharsetDecoder班时应使用在解码过程中需要更多的控制。
  
  Parameters:
  
  bytes -解码为字符的字节
  
  offset -第一个要解码的字节的索引
  
  length -字节数解码
  
  Throws:
  
  IndexOutOfBoundsException -如果 offset和 length参数指标的 bytes以外的字符数组的界限
  
  Since:
  
  JDK1.1
- String
```
public String(byte[] bytes)
```
  通过使用平台的默认字符集解码指定的字节数组构造了一个新的 String。新的 String长度是一个字符集的功能，因此可能不相等的字节数组的长度。
  这个构造函数的行为当给定字节无效的默认字符集是不确定的。的CharsetDecoder班时应使用在解码过程中需要更多的控制。
  
  Parameters:
  
  bytes -解码为字符的字节
  
  Since:
  
  JDK1.1
- String
```
public String(StringBuffer buffer)
```
  分配一个新的字符串，该字符串包含当前包含在字符串缓冲区中的字符的序列的字符串。字符串缓冲区的内容被复制；字符串缓冲区的随后的修改不会影响新创建的字符串。
  
  Parameters:
  
  buffer - StringBuffer
- String
```
public String(StringBuilder builder)
```
  分配一个新的字符串，该字符串包含当前包含在字符串生成器参数中的字符的序列。字符串生成器的内容被复制；字符串生成器的随后的修改不会影响新创建的字符串。
  此构造函数提供缓解迁移到StringBuilder。通过toString方法获得一个字符串生成字符串可能会跑得更快，一般是首选。
  
  Parameters:
  
  builder - StringBuilder
  
  Since:
  
  一点五

Method Detail

length
```
public int length()
```
返回此字符串的长度。长度等于字符串中的 Unicode code units数。

Specified by:

length 接口 CharSequence

Returns:

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

isEmpty
```
public boolean isEmpty()
```
返回 true如果，如果， length()是 0。

Returns:

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

Since:

一点六

charAt
```
public char charAt(int index)
```
返回指定索引的 char价值。指数范围从 0到 length() - 1。第一序列的 char值在指数 0，在指数 1下，等等，作为数组索引。
如果由索引指定的char值是一个surrogate，代孕的返回值。

Specified by:

charAt 接口 CharSequence

Parameters:

index的 char价值指数。

Returns:

在这个字符串中指定索引的 char价值。第一 char值在指数 0。

Throws:

IndexOutOfBoundsException -如果 index参数为负或不低于此字符串的长度。

codePointAt
```
public int codePointAt(int index)
```
返回字符（Unicode代码点）在指定的索引。该指数是指 char值（Unicode代码单元）和 0到 length() - 1范围。
如果在给定的索引指定的char值在高代理范围，下列指标低于本String长度，并在下列指标的char值是低代理范围，那么这个代理对相应的附加码点返回。否则，给定索引处的char返回值。

Parameters:

index -指数的 char值

Returns:

在 index字符的码值

Throws:

IndexOutOfBoundsException -如果 index参数为负或不低于此字符串的长度。

Since:

一点五

codePointBefore
```
public int codePointBefore(int index)
```
返回字符（Unicode代码点）在指定的索引。该指数是指 char值（Unicode代码单元）和 1到 length范围。
如果在(index - 1)的char值是低代理范围，(index - 2)不是消极的，并在(index - 2)的char值在高代理范围，然后代理项对的辅助码位的值被返回。如果在index - 1的char值是一个未成对的低或高的代孕代孕，代孕的返回值。

Parameters:

index跟踪代码点应该返回的索引

Returns:

Unicode代码点的值在给定的索引。

Throws:

IndexOutOfBoundsException -如果 index参数小于1或大于此字符串的长度。

Since:

一点五

codePointCount
```
public int codePointCount(int beginIndex,
                          int endIndex)
```
在这 String返回指定的文本范围的Unicode代码点。文本范围从指定的 beginIndex延伸在指数 endIndex - 1的 char。这样的长度（在 chars）的文本范围 endIndex-beginIndex。不成对的替代文本范围内的算一个代码点。

Parameters:

beginIndex -索引的文本范围的第一个 char。

endIndex -文本范围的最后 char后指数。

Returns:

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

Throws:

IndexOutOfBoundsException -如果 beginIndex是负的，或 endIndex大于这 String长度，或 beginIndex大于 endIndex。

Since:

一点五

offsetByCodePoints
```
public int offsetByCodePoints(int index,
                              int codePointOffset)
```
返回指数在这 String是从给定的 codePointOffset代码点 index偏移。不成对的代理人在文本范围的 index和 codePointOffset计数作为一个码点每。

Parameters:

index将抵消指数

在 codePointOffset -代码点偏移

Returns:

在这 String指数

Throws:

IndexOutOfBoundsException -如果 index阴性或大于这个 String长度，或者如果 codePointOffset正和子字符串从 index少于 codePointOffset代码点，或者如果 codePointOffset是负的，在 index少于 codePointOffset代码点的绝对值的子字符串。

Since:

一点五

getChars
```
public void getChars(int srcBegin,
                     int srcEnd,
                     char[] dst,
                     int dstBegin)
```
将此字符串的字符复制到目标字符数组中。
要复制的第一个字符是在指数srcBegin；要复制的最后一个字符是在指数srcEnd-1（这样的总字符数被复制是srcEnd-srcBegin）。字符复制到dst子数组的索引dstBegin开始和结束索引：
```
     dstbegin + (srcEnd-srcBegin) - 1
 
```
Parameters:

srcBegin指标字符串中第一个字符复制。

srcEnd -在字符串中的最后一个字符复制后指数。

dst -目标数组。

dstBegin的起始偏移在目标阵列。

Throws:
IndexOutOfBoundsException -如果任何以下是真实的：
- srcBegin是负的。
- srcBegin大于srcEnd
- srcEnd大于此字符串的长度
- dstBegin是负的
- dstBegin+(srcEnd-srcBegin)大于dst.length

getBytes
```
@Deprecated
public void getBytes(int srcBegin,
                                 int srcEnd,
                                 byte[] dst,
                                 int dstBegin)
```
过时的。这种方法不正确地将字符转换为字节。作为 JDK 1.1，这样的首选方式是通过getBytes()方法，它使用平台的默认字符集。
将此字符串的字符复制到目标字节数组中。每个字节接收相应字符的8个低阶位。每个字符的八个高阶位不被复制，不以任何方式参与传输。
要复制的第一个字符是在指数srcBegin；要复制的最后一个字符是在指数srcEnd-1。要复制的字符数srcEnd-srcBegin。字符，转换成字节，复制到dst子数组的索引dstBegin开始和结束索引：
```
     dstbegin + (srcEnd-srcBegin) - 1
 
```
Parameters:

srcBegin指标字符串中第一个字符复制

srcEnd -在字符串中的最后一个字符复制后指数

dst -目标数组

dstBegin的起始偏移在目标阵列

Throws:
IndexOutOfBoundsException -如果任何以下是真实的：
- srcBegin是负的
- srcBegin大于srcEnd
- srcEnd大于此字符串的长度
- dstBegin是负的
- dstBegin+(srcEnd-srcBegin)大于dst.length

getBytes
```
public byte[] getBytes(String charsetName)
                throws UnsupportedEncodingException
```
这 String编码成一个序列使用指定的字符的字节，并将结果存储到一个新的字节数组。
行为的这种方法在该字符串不能在给定的字符集编码不详。的CharsetEncoder班时应采用在编码过程中需要更多的控制。

Parameters:

charsetName -支持的 charset名称

Returns:

生成的字节数组

Throws:

UnsupportedEncodingException -如果指定的字符集不支持

Since:

JDK1.1

getBytes
```
public byte[] getBytes(Charset charset)
```
这 String编码为一个字节序列使用给定的 charset，结果存放到一个新的字节数组。
这种方法总是会替换格式不正确的输入，无法映射的字符序列，该字符集的默认置换的字节数组。的CharsetEncoder班时应采用在编码过程中需要更多的控制。

Parameters:

charset - Charset用来编码 String

Returns:

生成的字节数组

Since:

一点六

getBytes
```
public byte[] getBytes()
```
这 String编码成一个序列使用平台的默认字符集字节，结果存放到一个新的字节数组。
行为的这种方法在该字符串不能在默认字符集编码不详。的CharsetEncoder班时应采用在编码过程中需要更多的控制。

Returns:

生成的字节数组

Since:

JDK1.1

equals
```
public boolean equals(Object anObject)
```
将此字符串与指定的对象比较。其结果是 true如果只有参数不 null是 String表示相同的字符序列对象。

Overrides:

equals 上课 Object

Parameters:

anObject的对象比较 String反对

Returns:

true如果给定对象代表一个 String相当于这根弦， false否则

See Also:

compareTo(String)， equalsIgnoreCase(String)

contentEquals
```
public boolean contentEquals(StringBuffer sb)
```
比较这个字符串来指定 StringBuffer。结果是 true当且仅当这 String代表相同的字符序列指定的 StringBuffer。这种方法可以使得在 StringBuffer。

Parameters:

sb - StringBuffer比较 String反对

Returns:

如果这 true String代表相同的字符序列指定的 StringBuffer， false否则

Since:

一点四

contentEquals
```
public boolean contentEquals(CharSequence cs)
```
比较这个字符串来指定 CharSequence。其结果是 true当且仅当这 String代表字符值相同的序列指定的序列。注意，如果 CharSequence是 StringBuffer然后同步上。

Parameters:

cs序列的比较 String反对

Returns:

如果这 true String代表字符值相同的序列指定的序列， false否则

Since:

一点五

equalsIgnoreCase
```
public boolean equalsIgnoreCase(String anotherString)
```
比较这 String到另一个 String，忽略问题的考虑。两个字符串被认为是相等的忽略的情况下，如果他们是相同的长度和相应的字符在两个字符串是相等的忽略的情况下。
两个字c1和c2视为同一案件如果忽视下列中的至少一个是真的：
- 这两个字是相同的（相比的==算子）
- 应用该方法Character.toUpperCase(char)每个角色产生相同的结果
- 应用该方法Character.toLowerCase(char)每个角色产生相同的结果
Parameters:

anotherString - String比较 String反对

Returns:

true如果参数不是 null，它代表了一个相当 String忽视案例； false否则

See Also:

equals(Object)

compareTo
```
public int compareTo(String anotherString)
```
比较两个字符串的字典。比较是基于字符串中各个字符的Unicode值。这 String对象表示的字符序列是字典的比较参数字符串表示的字符序列。其结果是一个负整数，如果这 String对象字典先于参数字符串。其结果是一个正整数，如果这 String对象字典如下参数字符串。结果是零，如果字符串相等； compareTo返回 0何时 equals(Object)方法将返回 true。
这是字典排序的定义。如果两个字符串是不同的，那么它们要么有不同的字符，在一些索引，是一个有效的索引字符串，或它们的长度是不同的，或两者都有。如果他们在一个或多个索引的位置有不同的特点，让K是最小的指数；然后串在位置K的性格具有较小的值，通过 <算子确定，先于其他字符串的字典序。在这种情况下，compareTo返回在两个字符串，位置 k的两个特征值的差异，价值：
this.charAt(k)-anotherString.charAt(k) 如果没有索引位置的不同，则较短的字符串的字典序是更长的字符串。在这种情况下， compareTo返回的字符串，值的长度差： this.length()-anotherString.length()
Specified by: compareTo 接口 Comparable<String> Parameters: anotherString - String进行比较。 Returns: 价值 0如果参数字符串等于这个字符串；值小于 0如果这个字符串是字典序小于字符串参数；和一个值大于 0如果这个字符串的字典序大于字符串参数。

  
           
         
          compareToIgnoreCase
 public int compareToIgnoreCase(String str) 
          
           按字典顺序比较两个字符串，忽略大小写的差异。这个方法返回一个整数，其标志是，调用
           compareTo归一化版本的字符串的情况下的差异已由每个字符调用
           Character.toLowerCase(Character.toUpperCase(character))淘汰。
           请注意，此方法不需要现场的考虑，将导致某些地区理想的排序。java.text包提供的整合允许现场敏感的排序。
           
           
           
            Parameters:
            
           
            str - 
            String进行比较。
            
           
            Returns:
            
           
            一个负整数，零，或一个正整数作为指定的字符串是大于，等于或小于这个字符串，忽略的情况下考虑。
            
           
            Since:
            
           
            一点二
            
           
            See Also:
            
           
            Collator.compare(String, String)
            
          
  
        
  
           
         
          regionMatches
 public boolean regionMatches(int toffset,
                             String other,
                             int ooffset,
                             int len) 
          
           测试如果两个字符串区域是相等的。
           这String子对象进行比较的子字符串变量。如果这些子代表相同的字符序列的结果是真的。这String对象进行比较的字符串从指数toffset和长度len。其他可比指数ooffset串开始，长度len。其结果是false当且仅当下列中的至少一个是真的：
            
            toffset是负的。 
            ooffset是负的。 
            toffset+len大于这String对象的长度。 
            ooffset+len大于其他参数的长度。 
            有一些非负整数k小于len这样：this.charAt(toffset + k) != other.charAt(ooffset +  k) 
           
           
           
           
            Parameters:
            
           
            toffset -此字符串中的子区域的起始偏移。
            
           
            other -字符串参数。
            
           
            ooffset -在字符串参数的分区起始偏移。
            
           
            len -字符数比较。
            
           
            Returns:
            
           
            如果指定的区域
            true此字符串的指定区域的字符串完全匹配；
            false否则。
            
          
  
        
  
           
         
          regionMatches
 public boolean regionMatches(boolean ignoreCase,
                             int toffset,
                             String other,
                             int ooffset,
                             int len) 
          
           测试如果两个字符串区域是相等的。
           这String子对象相比，子串的说法other。其结果是true如果这些子串表示相同的字符序列，而忽略了当且仅当ignoreCase是真实的。这String对象进行比较的字符串从指数toffset和长度len，other来比较字符串开始在指数ooffset和长度len。结果是false当且仅当下列中的至少一个是真的：
            
            toffset是负的。 
            ooffset是负的。 
            toffset+len大于这String对象的长度。 
            ooffset+len大于其他参数的长度。 
            ignoreCase是false有非负整数k小于len这样： 
              
               this.charAt(toffset+k) != other.charAt(ooffset+k)
  
              
            ignoreCase是true有非负整数k小于len这样： 
              
               Character.toLowerCase(this.charAt(toffset+k)) !=
     Character.toLowerCase(other.charAt(ooffset+k))
  
             ： 
              
               Character.toUpperCase(this.charAt(toffset+k)) !=
         Character.toUpperCase(other.charAt(ooffset+k))
  
              
           
           
           
           
            Parameters:
            
           
            ignoreCase -如果
            true时，忽略字符比较。
            
           
            toffset -此字符串中的子区域的起始偏移。
            
           
            other -字符串参数。
            
           
            ooffset -在字符串参数的分区起始偏移。
            
           
            len -字符数比较。
            
           
            Returns:
            
           
            如果指定的区域
            true这个字符串匹配指定区域的字符串参数；
            false否则。是否匹配的准确或不区分大小写取决于
            ignoreCase论点。
            
          
  
        
  
           
         
          startsWith
 public boolean startsWith(String prefix,
                          int toffset) 
          
           如果此字符串中的指定索引处开始的子字符串从指定的前缀。
           
           
           
            Parameters:
            
           
            prefix -前缀。
            
           
            toffset -从哪里开始寻找这根弦。
            
           
            Returns:
            
           
            true如果参数表示的字符序列是一个前缀的这个对象的子从指数
            toffset；
            false否则。其结果是
            false如果
            toffset阴性或大于这个
            String对象的长度；否则结果作为表达式
            这个子串（toffset）从（前缀）。结果相同
            
          
  
        
  
           
         
          startsWith
 public boolean startsWith(String prefix) 
          
           测试这个字符串是否以指定的前缀开始。
           
           
           
            Parameters:
            
           
            prefix -前缀。
            
           
            Returns:
            
           
            true如果参数表示的字符序列是前缀的字符串表示的字符序列；
            false否则。注意，
            true将如果参数为空字符串或等于这
            String对象由
            equals(Object)法确定返回。
            
           
            Since:
            
           
            1。零
            
          
  
        
  
           
         
          endsWith
 public boolean endsWith(String suffix) 
          
           测试如果这个字符串以指定的后缀结束。
           
           
           
            Parameters:
            
           
            suffix -后缀。
            
           
            Returns:
            
           
            true如果参数表示的字符序列是一个后缀，该对象表示的字符序列；
            false否则。注意，结果将
            true如果参数为空字符串或等于这
            String对象由
            equals(Object)法测定。
            
          
  
        
  
           
         
          hashCode
 public int hashCode() 
          
           返回此字符串的哈希代码。一
           String对象的哈希码的计算是
            
             s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
  
           使用
           int算法，在
           s[i]是字符串的我这个角色，
           n是字符串的长度，和
           ^表示幂。（空字符串的哈希值为零。）
           
           
           
            Overrides:
            
           
            hashCode 上课 
            Object
            
           
            Returns:
            
           
            此对象的哈希代码值。
            
           
            See Also:
            
           
            Object.equals(java.lang.Object)，
            System.identityHashCode(java.lang.Object)
            
          
  
        
  
           
         
          indexOf
 public int indexOf(int ch) 
          
           返回在指定字符的第一个发生的字符串中的索引。如果一个有价值
           ch字符出现在这个
           String对象表示的字符序列，那么指数（Unicode代码单元）的首次发生返回。为
           ch范围中的值从0到0xFFFF（含），这是最小的K值如：
            
             this.charAt(k) == ch
  
           是真实的。为
           ch其他值，它是最小的K值如：
            
             this.codePointAt(k) == ch
  
           是真实的。在任何情况下，如果没有这样的人物出现在这个字符串，然后返回
           -1。
           
           
           
            Parameters:
            
           
            ch -一个字符（Unicode代码点）。
            
           
            Returns:
            
           
            对该对象表示的字符序列的字符的第一个匹配项的索引，或
            -1如果角色不发生。
            
          
  
        
  
           
         
          indexOf
 public int indexOf(int ch,
                   int fromIndex) 
          
           返回在指定字符的第一个发生的字符串中的索引，在指定的索引处开始搜索。
           如果一个有价值ch字符出现在比fromIndex小没有索引的String对象表示的字符序列，然后第一次发生的索引返回。为ch范围中的值从0到0xFFFF（含），这是最小的K值：
            
             (this.charAt(k) == ch)  && (k >= fromIndex)
  
           是真实的。为
           ch其他值，它是最小的K值如：
            
             (this.codePointAt(k) == ch)  && (k >= fromIndex)
  
           是真实的。在任何情况下，如果没有这样的人物出现在这个字符串或位置后，
           fromIndex，然后
           -1返回。
           在fromIndex值没有限制。如果它是否定的，它具有相同的效果，因为如果它是零：这个整个字符串可能被搜索。如果它大于此字符串的长度，它具有相同的效果，如果它等于此字符串的长度：-1返回。
           所有的指标是在char指定的值（Unicode代码单元）。
           
           
           
            Parameters:
            
           
            ch -一个字符（Unicode代码点）。
            
           
            fromIndex -开始搜索指数。
            
           
            Returns:
            
           
            对这个对象是大于或等于
            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向后从最后一个字符。
           
           
           
            Parameters:
            
           
            ch -一个字符（Unicode代码点）。
            
           
            Returns:
            
           
            对该对象表示的字符序列的字符最后一次出现的指标，或
            -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代码单元）。
           
           
           
            Parameters:
            
           
            ch -一个字符（Unicode代码点）。
            
           
            fromIndex -开始搜索指数。在
            fromIndex值没有限制。如果它大于或等于该字符串的长度，它具有相同的效果，因为如果它等于一个小于这个字符串的长度：这个整个字符串可能被搜索。如果它是否定的，它具有相同的效果，因为如果它是- 1：- 1返回。
            
           
            Returns:
            
           
            对这个对象是小于或等于
            fromIndex表示的字符序列的字符最后一次出现的指标，或
            -1如果字符不会出现在那之前。
            
          
  
        
  
           
         
          indexOf
 public int indexOf(String str) 
          
           返回指数在这个字符串指定的子字符串中第一个出现的。
           返回的索引是最小的值K：
            
             this.startsWith(str, k)
  
           如果K没有存在的价值，然后
           -1返回。
           
           
           
            Parameters:
            
           
            str -子串搜索。
            
           
            Returns:
            
           
            对指定的子字符串的第一个匹配项的索引，或
            -1如果没有发生。
            
          
  
        
  
           
         
          indexOf
 public int indexOf(String str,
                   int fromIndex) 
          
           返回此字符串的指定子字符串中第一个出现在索引中，从指定索引处开始。
           返回的索引是最小的值K：
            
             k >= fromIndex  && this.startsWith(str, k)
  
           如果K没有存在的价值，然后
           -1返回。
           
           
           
            Parameters:
            
           
            str -子串搜索。
            
           
            fromIndex -从开始搜索指数。
            
           
            Returns:
            
           
            对指定的子字符串的第一个匹配项的索引，从指定索引处开始，或
            -1如果没有发生。
            
          
  
        
  
           
         
          lastIndexOf
 public int lastIndexOf(String str) 
          
           返回指数在这个字符串的指定子字符串中最后出现。最后出现的空字符串“”是发生在指标值
           this.length()。
           返回的索引是最大的值K：
            
             this.startsWith(str, k)
  
           如果K没有存在的价值，然后
           -1返回。
           
           
           
            Parameters:
            
           
            str -子串搜索。
            
           
            Returns:
            
           
            对指定的子字符串的最后一个匹配项的索引，或
            -1如果没有发生。
            
          
  
        
  
           
         
          lastIndexOf
 public int lastIndexOf(String str,
                       int fromIndex) 
          
           返回此字符串的指定子字符串中最后出现在索引，搜索后从指定索引处开始。
           返回的索引是最大的值K：
            
             k  <= fromIndex  && this.startsWith(str, k)
  
           如果K没有存在的价值，然后
           -1返回。
           
           
           
            Parameters:
            
           
            str -子串搜索。
            
           
            fromIndex -开始搜索指数。
            
           
            Returns:
            
           
            对指定的子字符串的最后一个匹配项的索引，搜索后从指定的索引，或
            -1如果没有发生。
            
          
  
        
  
           
         
          substring
 public String substring(int beginIndex) 
          
           返回一个字符串，这个字符串的子串。子字符串从指定索引处的字符和延伸到这个字符串的末尾。
           实例：
            
             "unhappy".substring(2) returns "happy"
 "Harbison".substring(3) returns "bison"
 "emptiness".substring(9) returns "" (an empty string)
  
           
           
           
           
            Parameters:
            
           
            beginIndex开始的指标，包括。
            
           
            Returns:
            
           
            指定的子字符串。
            
           
            Throws:
            
           
            IndexOutOfBoundsException -如果
            beginIndex是消极的或比这
            String对象的长度。
            
          
  
        
  
           
         
          substring
 public String substring(int beginIndex,
                        int endIndex) 
          
           返回一个字符串，这个字符串的子串。子字符串从指定的
           beginIndex延伸在指数
           endIndex - 1特征。这样子串的长度是
           endIndex-beginIndex。
           实例：
            
             "hamburger".substring(4, 8) returns "urge"
 "smiles".substring(1, 5) returns "mile"
  
           
           
           
           
            Parameters:
            
           
            beginIndex开始的指标，包括。
            
           
            endIndex的结局指标，独家。
            
           
            Returns:
            
           
            指定的子字符串。
            
           
            Throws:
            
           
            IndexOutOfBoundsException -如果
            beginIndex是负的，或
            endIndex大于这
            String对象的长度，或
            beginIndex大于
            endIndex。
            
          
  
        
  
           
         
          subSequence
 public CharSequence subSequence(int beginIndex,
                                int endIndex) 
          
           返回一个字符序列的子序列。
           此方法的调用
            
             str.subSequence(begin, end) 
           表现一样，调用
            
             str.substring(begin, end) 
           
           
           
           
            Specified by:
            
           
            subSequence 接口 
            CharSequence
            
           
            API Note:
            
           
            这种方法的定义是这样
            String类可以实现接口的
            CharSequence。
            
           
            Parameters:
            
           
            beginIndex -开始指数、包容。
            
           
            endIndex结束的指标，独家。
            
           
            Returns:
            
           
            指定的子序列。
            
           
            Throws:
            
           
            IndexOutOfBoundsException -如果
            beginIndex或
            endIndex是负的，如果
            endIndex大于
            length()，或者如果
            beginIndex大于
            endIndex
            
           
            Since:
            
           
            一点四
            
          
  
        
  
           
         
          concat
 public String concat(String str) 
          
           将指定的字符串，此字符串的末尾。
           如果参数字符串的长度是0，那么这String对象返回。否则，一个String对象返回代表一个字符序列，是由这个String对象表示的字符序列拼接和字符序列的参数字符串表示。
           实例：
            
             "cares".concat("s") returns "caress"
 "to".concat("get").concat("her") returns "together"
  
           
           
           
           
            Parameters:
            
           
            str - 
            String，是连接到这个
            String结束。
            
           
            Returns:
            
           
            一个字符串，表示该对象的特征的级联其次是字符串的字符。
            
          
  
        
  
           
         
          replace
 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)
  
           
           
           
           
            Parameters:
            
           
            oldChar -旧的字符。
            
           
            newChar -新特征。
            
           
            Returns:
            
           
            通过更换
            oldChar与
            newChar每发生从这个字符串对应的字符串。
            
          
  
        
  
           
         
          matches
 public boolean matches(String regex) 
          
           告诉是否这个字符串匹配给定
           regular expression。
           这str.matches(正则表达式)产生完全相同的结果的表达形式的方法调用
            
            Pattern. 
            matches(regex, str) 
           
           
           
           
            Parameters:
            
           
            regex -正则表达式的字符串相匹配
            
           
            Returns:
            
           
            true如果，如果，这个字符串匹配给定的正则表达式
            
           
            Throws:
            
           
            PatternSyntaxException如果正则表达式的语法是无效的
            
           
            Since:
            
           
            一点四
            
           
            See Also:
            
           
            Pattern
            
          
  
        
  
           
         
          contains
 public boolean contains(CharSequence s) 
          
           如果并且只有当此字符串包含指定的字符序列的字符串值，则返回真值。
           
           
           
            Parameters:
            
           
            s -序列搜索
            
           
            Returns:
            
           
            如果这个字符串包含
            s真，否则为假
            
           
            Since:
            
           
            一点五
            
          
  
        
  
           
         
          replaceFirst
 public String replaceFirst(String regex,
                           String replacement) 
          
           代替这个字符串的替换，给
           regular expression匹配第一个字符串。
           这种形式的str.replaceFirst(正则表达式,取代)方法调用产生完全相同的结果的表达
            
             Pattern.compile(regex).matcher(str).replaceFirst(repl)  
            
           注意，反斜杠（\）和美元符号（$）在替换字符串中可能导致的结果是不同的比如果它被视为文字的替换字符串；看到Matcher.replaceFirst(java.lang.String)。使用Matcher.quoteReplacement(java.lang.String)抑制这些字符的特殊意义，如果需要的话。
           
           
           
            Parameters:
            
           
            regex -正则表达式的字符串相匹配
            
           
            replacement -可代替第一个匹配的字符串
            
           
            Returns:
            
           
            由此产生的
            String
            
           
            Throws:
            
           
            PatternSyntaxException如果正则表达式的语法是无效的
            
           
            Since:
            
           
            一点四
            
           
            See Also:
            
           
            Pattern
            
          
  
        
  
           
         
          replaceAll
 public String replaceAll(String regex,
                         String replacement) 
          
           每个子串替换该字符串的给予更换，给
           regular expression比赛。
           这str.replaceAll(正则表达式,取代)产生完全相同的结果的表达形式的方法调用
            
             Pattern.compile(regex).matcher(str).replaceAll(repl)  
            
           注意，反斜杠（\）和美元符号（$）在替换字符串中可能导致的结果是不同的比如果它被视为文字的替换字符串；看到Matcher.replaceAll。使用Matcher.quoteReplacement(java.lang.String)抑制这些字符的特殊意义，如果需要的话。
           
           
           
            Parameters:
            
           
            regex -正则表达式的字符串相匹配
            
           
            replacement -被取代为每个匹配的字符串
            
           
            Returns:
            
           
            由此产生的
            String
            
           
            Throws:
            
           
            PatternSyntaxException如果正则表达式的语法是无效的
            
           
            Since:
            
           
            一点四
            
           
            See Also:
            
           
            Pattern
            
          
  
        
  
           
         
          replace
 public String replace(CharSequence target,
                      CharSequence replacement) 
          
           每个子串替换该字符串指定的文本替换序列靶序列匹配的文字。更换从字符串的开始到结束，例如，取代“AA”与“B”系列中的“AAA”将导致“巴”而不是“AB”。
           
           
           
            Parameters:
            
           
            target -字符值被替换的序列
            
           
            replacement的char值置换序列
            
           
            Returns:
            
           
            结果字符串
            
           
            Since:
            
           
            一点五
            
          
  
        
  
           
         
          split
 public 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" } 
               
              
             
            
           这结构split(正则表达式, n)得到相同的结果作为表现形式的方法调用
            
             Pattern.compile(regex).split(str, n)  
           
           
           
           
            Parameters:
            
           
            regex -定义的正则表达式
            
           
            limit结果阈值，如上
            
           
            Returns:
            
           
            通过分裂这个字符串来计算给定正则表达式的匹配的字符串数组
            
           
            Throws:
            
           
            PatternSyntaxException如果正则表达式的语法是无效的
            
           
            Since:
            
           
            一点四
            
           
            See Also:
            
           
            Pattern
            
          
  
        
  
           
         
          split
 public String[] split(String regex) 
          
           将此字符串在给定的
           regular expression比赛。
           这种方法是通过调用两split如果论证方法与给定的表达和零的极限参数。因此不包括在结果数组中的尾随空字符串。
           例如，字符串"boo:and:foo"，得到以下结果与这些表达式：
            
             
              
               
               Regex 
               Result 
               
               
               : 
               { "boo", "and", "foo" } 
               
               
               o 
               { "b", "", ":and:f" } 
               
              
             
           
           
           
           
            Parameters:
            
           
            regex -定义的正则表达式
            
           
            Returns:
            
           
            通过分裂这个字符串来计算给定正则表达式的匹配的字符串数组
            
           
            Throws:
            
           
            PatternSyntaxException如果正则表达式的语法是无效的
            
           
            Since:
            
           
            一点四
            
           
            See Also:
            
           
            Pattern
            
          
  
        
  
           
         
          join
 public static String join(CharSequence delimiter,
                          CharSequence... elements) 
          
           返回一个由
           CharSequence elements副本的新字符串连接在一起的一份指定的
           delimiter。
           
             For example, 
            
     String message = String.join("-", "Java", "is", "cool");
     // message returned is: "Java-is-cool"
  
           注意，如果一个元素是空的，然后
           "null"添加。
           
           
           
            Parameters:
            
           
            delimiter -分隔符分隔的每个元素
            
           
            elements -一起加入的元素。
            
           
            Returns:
            
           
            一个新的
            String，组成的
            elements由
            delimiter分离
            
           
            Throws:
            
           
            NullPointerException -如果
            delimiter或
            elements是
            null
            
           
            Since:
            
           
            一点八
            
           
            See Also:
            
           
            StringJoiner
            
          
  
        
  
           
         
          join
 public static String join(CharSequence delimiter,
                          Iterable<? extends CharSequence> elements) 
          
           返回一个由
           CharSequence elements 
           String加入新的副本，连同一份指定的
           delimiter。
           
             For example, 
            
     List<String> strings = new LinkedList<>();
     strings.add("Java");strings.add("is");
     strings.add("cool");
     String message = String.join(" ", strings);
     //message returned is: "Java is cool"

     Set<String> strings = new LinkedHashSet<>();
     strings.add("Java"); strings.add("is");
     strings.add("very"); strings.add("cool");
     String message = String.join("-", strings);
     //message returned is: "Java-is-very-cool"
  
           注意，如果一个元素是
           null，然后
           "null"添加。
           
           
           
            Parameters:
            
           
            delimiter -一个字符序列，使用单独的每个的
            elements在产生的
            String
            
           
            elements - 
            Iterable将其
            elements一起。
            
           
            Returns:
            
           
            一个新的
            String是从
            elements参数组成
            
           
            Throws:
            
           
            NullPointerException -如果
            delimiter或
            elements是
            null
            
           
            Since:
            
           
            一点八
            
           
            See Also:
            
           
            join(CharSequence,CharSequence...)，
            StringJoiner
            
          
  
        
  
           
         
          toLowerCase
 public String toLowerCase(Locale locale) 
          
           将所有的角色在这
           String以较低的情况下使用给定的
           Locale规则。例图是基于Unicode的标准版本
           Character类指定。由于案件映射并不总是1:1的字符映射，得到的
           String可能比原来的
           String 
           小写映射的例子在下表中：
            
             
              
              Language Code of Locale 
              Upper Case 
              Lower Case 
              Description 
              
              
              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 
              
             
           不同长度。
           
           
           
            Parameters:
            
           
            locale使用案例的转换规则，这个现场
            
           
            Returns:
            
           
            的
            String，转换为小写。
            
           
            Since:
            
           
            一点一
            
           
            See Also:
            
           
            toLowerCase()，
            toUpperCase()，
            toUpperCase(Locale)
            
          
  
        
  
           
         
          toLowerCase
 public String toLowerCase() 
          
           将所有的角色在这
           String以较低的情况下使用默认的区域设置规则。这相当于调用
           toLowerCase(Locale.getDefault())。
           这种方法是注：现场敏感，并可用于打算解释现场独立字符串产生意外的结果。实例编程语言标识符，协议的密钥，和HTML标签。例如，"TITLE".toLowerCase()在土耳其现场返回"t\u0131tle"，那里的u0131是拉丁文小写字母带点我的性格。获得现场敏感字符串正确的结果，使用toLowerCase(Locale.ROOT)。
           
           
           
           
            Returns:
            
           
            的
            String，转换为小写。
            
           
            See Also:
            
           
            toLowerCase(Locale)
            
          
  
        
  
           
         
          toUpperCase
 public String toUpperCase(Locale locale) 
          
           将所有的角色在这
           String大写使用给定的
           Locale规则。案例映射是基于Unicode的标准版本
           Character类指定。由于案件映射并不总是1:1的字符映射，得到的
           String可能比原来的
           String不同长度。
           现场敏感和1：M的情况下映射的例子在下表中。
            
             
              
              Language Code of Locale 
              Lower Case 
              Upper Case 
              Description 
              
              
              tr (Turkish) 
              \u0069 
              \u0130 
              small letter i -> capital letter I with dot above 
              
              
              tr (Turkish) 
              \u0131 
              \u0049 
              small letter dotless i -> capital letter I 
              
              
              (all) 
              \u00df 
              \u0053 \u0053 
              small letter sharp s -> two letters: SS 
              
              
              (all) 
              Fahrvergnügen 
              FAHRVERGNÜGEN 
               
              
             
           
           
           
           
            Parameters:
            
           
            locale使用案例的转换规则，这个现场
            
           
            Returns:
            
           
            的
            String，转换为大写。
            
           
            Since:
            
           
            一点一
            
           
            See Also:
            
           
            toUpperCase()，
            toLowerCase()，
            toLowerCase(Locale)
            
          
  
        
  
           
         
          toUpperCase
 public String toUpperCase() 
          
           将所有的角色在这
           String上使用的默认区域设置规则。这种方法相当于
           这种方法是注：现场敏感，并可用于打算解释现场独立字符串产生意外的结果。实例编程语言标识符，协议的密钥，和HTML标签。例如，"title".toUpperCase()在土耳其现场返回"T\u0130TLE"，那里的u0130是拉丁文大写字母我点上面的字。获得现场敏感字符串正确的结果，使用toUpperCase(Locale.ROOT)。
            
           toUpperCase(Locale.getDefault())。
           
           
           
            Returns:
            
           
            的
            String，转换为大写。
            
           
            See Also:
            
           
            toUpperCase(Locale)
            
          
  
        
  
           
         
          trim
 public String trim() 
          
           返回一个字符串，它的值是字符串，任何前导和尾随空格删除。
           如果这String对象代表一个空字符或字符序列的序列，这String对象都有码大于'\u0020'为代表的第一个和最后一个字符（空格），然后参考这个String对象返回。
           否则，如果有一个代码大于字符串'\u0020'没有字符，然后String表示对象返回一个空字符串。
           否则，让K是在字符串的编码大于'\u0020'第一个字符的索引，让我可以在字符串的编码大于'\u0020'的最后一个字符的索引。一个String对象返回，表示此字符串，首先在指数m-that特征指数K和结束字符的子串，this.substring(k, m + 1)的结果。
           这种方法可以用来装饰的空白（如上文）从字符串的开头和结尾。
           
           
           
            Returns:
            
           
            一个字符串，其值是这个字符串，任何领先的和尾随的白色空间删除，或此字符串，如果它没有领先的或尾随的白色空间。
            
          
  
        
  
           
         
          toString
 public String toString() 
          
           这个对象（这已经是一个字符串！）是自己回来了。
           
           
           
            Specified by:
            
           
            toString 接口 
            CharSequence
            
           
            Overrides:
            
           
            toString 上课 
            Object
            
           
            Returns:
            
           
            字符串本身。
            
          
  
        
  
           
         
          toCharArray
 public char[] toCharArray() 
          
           将此字符串转换为一个新的字符数组。
           
           
           
            Returns:
            
           
            一种新分配的字符数组，其长度是该字符串的长度，其内容被初始化为包含由该字符串表示的字符序列。
            
          
  
        
  
           
         
          format
 public static String format(String format,
                            Object... args) 
          
           使用指定的格式字符串和参数返回格式化的字符串。
           经常使用的区域是一个由Locale.getDefault()。
           
           
           
            Parameters:
            
           
            format - 
            format string
            
           
            args由格式字符串的格式说明符引用的论据。如果有比格式说明符的更多参数，多余的参数会被忽略。参数的数量是可变的，可能是零。参数的最大数量是由一个java数组的定义由
            The Java™ Virtual Machine Specification最大尺寸的限制。在
            null争论的行为取决于
            conversion。
            
           
            Returns:
            
           
            格式化字符串
            
           
            Throws:
            
           
            IllegalFormatException如果格式字符串包含一个非法的语法、格式说明符与给定的参数不兼容，论据不足给定的格式字符串，或者其他非法的条件。对于所有可能的格式错误的规范，看到格式化程序类规范的
            Details节。
            
           
            Since:
            
           
            一点五
            
           
            See Also:
            
           
            Formatter
            
          
  
        
  
           
         
          format
 public static String format(Locale l,
                            String format,
                            Object... args) 
          
           使用指定的区域设置、格式字符串和参数返回格式化的字符串。
           
           
           
            Parameters:
            
           
            l - 
            locale申请过程中的格式。如果
            l是
            null然后不采用定位。
            
           
            format - 
            format string
            
           
            args由格式字符串的格式说明符引用的论据。如果有比格式说明符的更多参数，多余的参数会被忽略。参数的数量是可变的，可能是零。参数的最大数量是由一个java数组的定义由
            The Java™ Virtual Machine Specification最大尺寸的限制。在
            null争论的行为取决于
            conversion。
            
           
            Returns:
            
           
            格式化字符串
            
           
            Throws:
            
           
            IllegalFormatException如果格式字符串包含一个非法的语法、格式说明符与给定的参数不兼容，论据不足给定的格式字符串，或者其他非法的条件。对于所有可能的格式错误的规范，看到格式化程序类规范的
            Details节
            
           
            Since:
            
           
            一点五
            
           
            See Also:
            
           
            Formatter
            
          
  
        
  
           
         
          valueOf
 public static String valueOf(Object obj) 
          
           返回的
           Object参数的字符串表示形式。
           
           
           
            Parameters:
            
           
            obj - 
            Object。
            
           
            Returns:
            
           
            如果参数是一个字符串，然后
            null，等于
            "null"；否则，返回的值的
            obj.toString()。
            
           
            See Also:
            
           
            Object.toString()
            
          
  
        
  
           
         
          valueOf
 public static String valueOf(char[] data) 
          
           返回的
           char数组参数的字符串表示形式。字符数组的内容被复制；字符数组的随后的修改不影响返回的字符串。
           
           
           
            Parameters:
            
           
            data的字符数组。
            
           
            Returns:
            
           
            一个
            String包含的字符数组的特点。
            
          
  
        
  
           
         
          valueOf
 public static String valueOf(char[] data,
                             int offset,
                             int count) 
          
           返回一个特定的子阵的
           char数组参数的字符串表示形式。
           的说法是offset的子阵列的第一个字符的索引。count参数指定的数组的长度。的子阵列的内容复制的字符数组；随后的修改不影响返回的字符串。
           
           
           
            Parameters:
            
           
            data的字符数组。
            
           
            offset -子阵初始偏移。
            
           
            count -子阵的长度。
            
           
            Returns:
            
           
            一个
            String包含指定的字符数组的字符数组。
            
           
            Throws:
            
           
            IndexOutOfBoundsException -如果
            offset是负的，或
            count是负的，或
            offset+count大于
            data.length。
            
          
  
        
  
           
         
          copyValueOf
 public static String copyValueOf(char[] data,
                                 int offset,
                                 int count) 
          
           相当于
           valueOf(char[], int, int)。
           
           
           
            Parameters:
            
           
            data的字符数组。
            
           
            offset -子阵初始偏移。
            
           
            count -子阵的长度。
            
           
            Returns:
            
           
            一个
            String包含指定的字符数组的字符数组。
            
           
            Throws:
            
           
            IndexOutOfBoundsException -如果
            offset是负的，或
            count是负的，或
            offset+count大于
            data.length。
            
          
  
        
  
           
         
          copyValueOf
 public static String copyValueOf(char[] data) 
          
           相当于
           valueOf(char[])。
           
           
           
            Parameters:
            
           
            data的字符数组。
            
           
            Returns:
            
           
            一个
            String包含的字符数组的特点。
            
          
  
        
  
           
         
          valueOf
 public static String valueOf(boolean b) 
          
           返回的
           boolean参数的字符串表示形式。
           
           
           
            Parameters:
            
           
            b - 
            boolean。
            
           
            Returns:
            
           
            如果参数是一个字符串
            true，等于
            "true"返回；否则，返回一个字符串相等
            "false"。
            
          
  
        
  
           
         
          valueOf
 public static String valueOf(char c) 
          
           返回的
           char参数的字符串表示形式。
           
           
           
            Parameters:
            
           
            c - 
            char。
            
           
            Returns:
            
           
            字符串的长度
            1含为单个字符的参数
            c。
            
          
  
        
  
           
         
          valueOf
 public static String valueOf(int i) 
          
           返回的
           int参数的字符串表示形式。
           表示是完全由一个参数的Integer.toString方法返回。
           
           
           
            Parameters:
            
           
            i - 
            int。
            
           
            Returns:
            
           
            int参数的字符串表示形式。
            
           
            See Also:
            
           
            Integer.toString(int, int)
            
          
  
        
  
           
         
          valueOf
 public static String valueOf(long l) 
          
           返回的
           long参数的字符串表示形式。
           表示是完全由一个参数的Long.toString方法返回。
           
           
           
            Parameters:
            
           
            l - 
            long。
            
           
            Returns:
            
           
            long参数的字符串表示形式。
            
           
            See Also:
            
           
            Long.toString(long)
            
          
  
        
  
           
         
          valueOf
 public static String valueOf(float f) 
          
           返回的
           float参数的字符串表示形式。
           表示是完全由一个参数的Float.toString方法返回。
           
           
           
            Parameters:
            
           
            f - 
            float。
            
           
            Returns:
            
           
            float参数的字符串表示形式。
            
           
            See Also:
            
           
            Float.toString(float)
            
          
  
        
  
           
         
          valueOf
 public static String valueOf(double d) 
          
           返回的
           double参数的字符串表示形式。
           表示是完全由一个参数的Double.toString方法返回。
           
           
           
            Parameters:
            
           
            d - 
            double。
            
           
            Returns:
            
           
            double参数的字符串表示形式。
            
           
            See Also:
            
           
            Double.toString(double)
            
          
  
        
  
           
         
          intern
 public 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定义。
           
           
           
            Returns:
            
           
            一个具有与此字符串相同的内容的字符串，但保证是从一个独特的字符串池。

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" }`

Language Code of Locale	Upper Case	Lower Case	Description
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

Class String

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Field Detail

CASE_INSENSITIVE_ORDER

Constructor Detail

String

String

String

String

String

String

String

String

String

String

String

String

String

String

String

Method Detail

length

isEmpty

charAt

codePointAt

codePointBefore

codePointCount

offsetByCodePoints

getChars

getBytes

getBytes

getBytes

getBytes

equals

contentEquals

contentEquals

equalsIgnoreCase

compareTo

compareToIgnoreCase

regionMatches

regionMatches

startsWith

startsWith

endsWith

hashCode

indexOf

indexOf

lastIndexOf

lastIndexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

substring

substring

subSequence

concat

replace

matches

contains

replaceFirst

replaceAll

replace

split

split

join

join

toLowerCase

toLowerCase

toUpperCase

toUpperCase

trim

toString

toCharArray

format

format