java.lang.Object

java.lang.String

所有已实现的接口:: Serializable, CharSequence, Comparable<String>, Constable, ConstantDesc

public final class String extends Object implements Serializable, Comparable<String>, CharSequence, Constable, ConstantDesc

String类表示字符字符串。Java程序中的所有字符串文字，例如"abc"，都作为该类的实例实现。

字符串是常量；它们的值在创建后不能更改。字符串缓冲区支持可变字符串。由于String对象是不可变的，它们可以被共享。例如：

     String str = "abc";

等同于：

     char data[] = {'a', 'b', 'c'};
     String str = new String(data);

以下是字符串如何使用的更多示例：

     System.out.println("abc");
     String cde = "cde";
     System.out.println("abc" + cde);
     String c = "abc".substring(2, 3);
     String d = cde.substring(1, 2);

String类包括用于检查序列中的单个字符、比较字符串、搜索字符串、提取子字符串以及创建所有字符转换为大写或小写的字符串副本的方法。大小写映射基于由Character类指定的Unicode标准版本。

Java语言为字符串连接运算符（ + ）提供特殊支持，以及将其他对象转换为字符串。有关字符串连接和转换的其他信息，请参阅《Java语言规范》。

除非另有说明，在该类的构造函数或方法中传递null参数将导致抛出NullPointerException。

String以UTF-16格式表示字符串，其中补充字符由代理对表示（有关更多信息，请参见Character类中的Unicode字符表示部分）。索引值指的是char代码单元，因此补充字符在String中使用两个位置。

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

除非另有说明，用于比较字符串的方法不考虑区域设置。Collator类提供了更精细、区域设置敏感的字符串比较方法。

实现注意事项:

字符串连接运算符的实现留给Java编译器自行决定，只要编译器最终符合《Java语言规范》即可。例如，根据JDK版本，javac编译器可以使用StringBuffer、StringBuilder或java.lang.invoke.StringConcatFactory来实现该运算符。字符串转换的实现通常通过Object定义的toString方法来实现，并由Java中的所有类继承。

参见《Java语言规范》:

15.18.1 字符串连接运算符 +

自版本:

1.0

另请参阅:

Field Summary

Fields

Modifier and Type

Field

Description

static final Comparator<String>

CASE_INSENSITIVE_ORDER

一个比较器，按compareToIgnoreCase对String对象进行排序。
Constructor Summary

Constructors

Constructor

Description

String()

初始化一个新创建的String对象，使其表示空字符序列。

String(byte[] bytes)

使用默认字符集解码指定的字节数组构造一个新的String。

String(byte[] ascii, int hibyte)

已弃用。
此方法未正确将字节转换为字符。

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

使用默认字符集解码指定的字节数组的子数组构造一个新的String。

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

已弃用。
此方法未正确将字节转换为字符。

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

使用指定的字符集解码指定的字节数组的子数组构造一个新的String。

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

使用指定的字符集解码指定的字节数组的子数组构造一个新的String。

String(byte[] bytes, String charsetName)

使用指定的字符集解码指定的字节数组构造一个新的String。

String(byte[] bytes, Charset charset)

使用指定的字符集解码指定的字节数组构造一个新的String。

String(char[] value)

分配一个新的String，使其表示当前包含在字符数组参数中的字符序列。

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

分配一个新的String，其中包含字符数组参数的子数组中的字符。

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

分配一个新的String，其中包含Unicode代码点数组参数的子数组中的字符。

String(String original)

初始化一个新创建的String对象，使其表示与参数相同的字符序列；换句话说，新创建的字符串是参数字符串的副本。

String(StringBuffer buffer)

分配一个新的字符串，其中包含当前包含在字符串缓冲区参数中的字符序列。

String(StringBuilder builder)

分配一个新的字符串，其中包含当前包含在字符串构建器参数中的字符序列。
Method Summary

Modifier and Type

Method

Description

char

charAt(int index)

返回指定索引处的char值。

IntStream

chars()

返回从该序列中的char值零扩展的int值流。

int

codePointAt(int index)

返回指定索引处的字符（Unicode代码点）。

int

codePointBefore(int index)

返回指定索引之前的字符（Unicode代码点）。

int

codePointCount(int beginIndex, int endIndex)

返回该String的指定文本范围内的Unicode代码点数。

IntStream

codePoints()

返回从该序列中的代码点值流。

int

compareTo(String anotherString)

按字典顺序比较两个字符串。

int

compareToIgnoreCase(String str)

按字典顺序比较两个字符串，忽略大小写差异。

String

concat(String str)

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

boolean

contains(CharSequence s)

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

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)。

Optional<String>

describeConstable()

返回包含此实例的名义描述符的Optional，即实例本身。

boolean

endsWith(String suffix)

测试此字符串是否以指定后缀结束。

boolean

equals(Object anObject)

将此字符串与指定对象进行比较。

boolean

equalsIgnoreCase(String anotherString)

将此String与另一个String进行比较，忽略大小写。

static String

format(String format, Object... args)

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

static String

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

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

String

formatted(Object... args)

使用此字符串作为格式字符串，并使用提供的参数进行格式化。

byte[]

getBytes()

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

void

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

已弃用。
此方法未正确将字符转换为字节。

byte[]

getBytes(String charsetName)

使用命名字符集将此String编码为字节序列，将结果存储到新的字节数组中。

byte[]

getBytes(Charset charset)

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

void

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

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

int

hashCode()

返回此字符串的哈希码。

String

indent(int n)

根据n的值调整此字符串每行的缩进，并规范化行终止字符。

int

indexOf(int ch)

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

int

indexOf(int ch, int fromIndex)

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

int

indexOf(int ch, int beginIndex, int endIndex)

返回指定字符的第一次出现在此字符串中的索引，从beginIndex开始搜索，直到endIndex之前停止。

int

indexOf(String str)

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

int

indexOf(String str, int fromIndex)

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

int

indexOf(String str, int beginIndex, int endIndex)

返回指定子字符串在此字符串指定索引范围内第一次出现的索引。

String

intern()

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

boolean

isBlank()

如果字符串为空或仅包含空格代码点，则返回true，否则返回false。

boolean

isEmpty()

如果且仅当length()为0时返回true。

static String

join(CharSequence delimiter, CharSequence... elements)

返回由CharSequence元素的副本与指定delimiter的副本连接在一起组成的新字符串。

static String

join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

返回由CharSequence元素的副本与指定delimiter的副本连接在一起组成的新String。

int

lastIndexOf(int ch)

返回指定字符在此字符串中最后一次出现的索引。

int

lastIndexOf(int ch, int fromIndex)

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

int

lastIndexOf(String str)

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

int

lastIndexOf(String str, int fromIndex)

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

int

length()

返回此字符串的长度。

Stream<String>

lines()

返回从此字符串中提取的以行终止符分隔的行的流。

boolean

matches(String regex)

检查此字符串是否与给定的正则表达式匹配。

int

offsetByCodePoints(int index, int codePointOffset)

返回从给定index偏移codePointOffset代码点的此String中的索引。

boolean

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

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

boolean

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

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

String

repeat(int count)

返回一个值为此字符串重复count次的字符串。

String

replace(char oldChar, char newChar)

返回将此字符串中所有oldChar的出现替换为newChar的字符串。

String

replace(CharSequence target, CharSequence replacement)

用指定的替换序列替换此字符串中与字面目标序列匹配的每个子字符串。

String

replaceAll(String regex, String replacement)

用给定的替换替换此字符串中与给定正则表达式匹配的每个子字符串。

String

replaceFirst(String regex, String replacement)

用给定替换替换此字符串中与给定正则表达式匹配的第一个子字符串。

String

resolveConstantDesc(MethodHandles.Lookup lookup)

将此实例解析为ConstantDesc，其结果是实例本身。

String[]

split(String regex)

围绕给定正则表达式的匹配拆分此字符串。

String[]

split(String regex, int limit)

围绕给定正则表达式的匹配拆分此字符串。

String[]

splitWithDelimiters(String regex, int limit)

围绕给定正则表达式的匹配拆分此字符串，并返回字符串和匹配的分隔符。

boolean

startsWith(String prefix)

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

boolean

startsWith(String prefix, int toffset)

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

String

strip()

返回值为此字符串，删除所有前导和尾随空格的字符串。

String

stripIndent()

返回值为此字符串，删除每行开头和结尾的所有偶然空格的字符串。

String

stripLeading()

返回值为此字符串，删除所有前导空格的字符串。

String

stripTrailing()

返回值为此字符串，删除所有尾随空格的字符串。

CharSequence

subSequence(int beginIndex, int endIndex)

返回此序列的子序列的字符序列。

String

substring(int beginIndex)

返回此字符串的子字符串。

String

substring(int beginIndex, int endIndex)

返回此字符串的子字符串。

char[]

toCharArray()

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

String

toLowerCase()

使用默认区域设置规则将此String中的所有字符转换为小写。

String

toLowerCase(Locale locale)

使用给定Locale的规则将此String中的所有字符转换为小写。

String

toString()

此对象（已经是一个字符串！）

String

toUpperCase()

使用默认区域设置规则将此String中的所有字符转换为大写。

String

toUpperCase(Locale locale)

使用给定Locale的规则将此String中的所有字符转换为大写。

<R> R

transform(Function<? super String,? extends R> f)

此方法允许将函数应用于this字符串。

String

translateEscapes()

返回值为此字符串，其中转义序列被翻译为字符串文字中的转义序列。

String

trim()

返回值为此字符串，其中删除了所有前导和尾随空格，其中空格定义为其代码点小于或等于'U+0020'（空格字符）的任何字符。

static String

valueOf(boolean b)

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

static String

valueOf(char c)

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

static String

valueOf(char[] data)

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

static String

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

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

static String

valueOf(double d)

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

static String

valueOf(float f)

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

static String

valueOf(int i)

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

static String

valueOf(long l)

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

static String

valueOf(Object obj)

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

Methods declared in class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Details
- CASE_INSENSITIVE_ORDER
  
  public static final Comparator<String> CASE_INSENSITIVE_ORDER
  
  一个比较器，按照compareToIgnoreCase对String对象进行排序。此比较器是可序列化的。
  请注意，此比较器不考虑区域设置，对于某些区域设置，将导致不满意的排序。 Collator类提供区域设置敏感的比较。
  自：
  
  1.2
  
  参见：
  
  Collator
Constructor Details
- String
  
  public String()
  
  初始化新创建的String对象，使其表示空字符序列。请注意，由于字符串是不可变的，因此不需要使用此构造函数。
- String
  
  public String(String original)
  
  初始化新创建的String对象，使其表示与参数相同的字符序列；换句话说，新创建的字符串是参数字符串的副本。除非需要显式复制original，否则不需要使用此构造函数，因为字符串是不可变的。
  
  参数：
  
  original - 一个String
- String
  
  public String(char[] value)
  
  分配一个新的String，以表示当前包含在字符数组参数中的字符序列。字符数组的内容将被复制；对字符数组的后续修改不会影响新创建的字符串。
  
  参数：
  
  value - 字符串的初始值
- String
  
  public String(char[] value, int offset, int count)
  
  分配一个新的String，其中包含字符数组参数的子数组中的字符。 offset参数是子数组的第一个字符的索引，count参数指定子数组的长度。子数组的内容将被复制；对字符数组的后续修改不会影响新创建的字符串。
  
  参数：
  
  value - 作为字符源的数组
  
  offset - 初始偏移量
  
  count - 长度
  
  抛出：
  
  IndexOutOfBoundsException - 如果offset为负，count为负，或offset大于value.length - count
- String
  
  public String(int[] codePoints, int offset, int count)
  
  分配一个新的String，其中包含Unicode代码点数组参数的子数组中的字符。 offset参数是子数组的第一个代码点的索引，count参数指定子数组的长度。子数组的内容将转换为char；对int数组的后续修改不会影响新创建的字符串。
  
  参数：
  
  codePoints - 作为Unicode代码点源的数组
  
  offset - 初始偏移量
  
  count - 长度
  
  抛出：
  
  IllegalArgumentException - 如果在 codePoints中发现任何无效的Unicode代码点
  
  IndexOutOfBoundsException - 如果offset为负，count为负，或offset大于codePoints.length - count
  
  自：
  
  1.5
- String
  
  @Deprecated(since="1.1") public String(byte[] ascii, int hibyte, int offset, int count)
  
  Deprecated.
  This method does not properly convert bytes into characters. As of JDK 1.1, the preferred way to do this is via the String constructors that take a Charset, charset name, or that use the default charset.
  
  分配一个新的String，由8位整数值数组的子数组构造。
  offset参数是子数组的第一个字节的索引，count参数指定子数组的长度。
  
  子数组中的每个byte将按照String(byte[],int)构造函数中指定的方式转换为char。
  参数:
  
  ascii - 要转换为字符的字节
  
  hibyte - 每个16位Unicode代码单元的前8位
  
  offset - 初始偏移量
  
  count - 长度
  
  抛出:
  
  IndexOutOfBoundsException - 如果offset为负、count为负或offset大于ascii.length - count
  
  参见:
  
  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(since="1.1") public String(byte[] ascii, int hibyte)
  
  Deprecated.
  This method does not properly convert bytes into characters. As of JDK 1.1, the preferred way to do this is via the String constructors that take a Charset, charset name, or that use the default charset.
  分配一个新的String，其中包含从8位整数值数组构造的字符。结果字符串中的每个字符是从字节数组中的相应组件构造的，使得：
  
  c == (char)(((hibyte & 0xff) << 8) | (b & 0xff))
  参数:
  
  ascii - 要转换为字符的字节
  
  hibyte - 每个16位Unicode代码单元的前8位
  
  参见:
  
  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类。
  
  参数:
  
  bytes - 要解码为字符的字节
  
  offset - 要解码的第一个字节的索引
  
  length - 要解码的字节数
  
  charsetName - 支持的字符集的名称
  
  抛出:
  
  UnsupportedEncodingException - 如果命名的字符集不受支持
  
  IndexOutOfBoundsException - 如果offset为负、length为负或offset大于bytes.length - length
  
  自:
  
  1.1
- String
  
  public String(byte[] bytes, int offset, int length, Charset charset)
  
  通过使用指定字符集解码字节数组的指定子数组来构造一个新的String。新String的长度取决于字符集，因此可能不等于子数组的长度。
  此方法始终使用此字符集的默认替换字符串替换格式错误的输入和无法映射的字符序列。当需要对解码过程进行更多控制时，应使用CharsetDecoder类。
  
  参数:
  
  bytes - 要解码为字符的字节
  
  offset - 要解码的第一个字节的索引
  
  length - 要解码的字节数
  
  charset - 用于解码bytes的字符集
  
  抛出:
  
  IndexOutOfBoundsException - 如果offset为负、length为负或offset大于bytes.length - length
  
  自:
  
  1.6
- String
  
  public String(byte[] bytes, String charsetName) throws UnsupportedEncodingException
  
  通过使用指定字符集解码字节数组来构造一个新的String。新String的长度取决于字符集，因此可能不等于字节数组的长度。
  当给定的字节在给定字符集中无效时，此构造函数的行为是未指定的。当需要对解码过程进行更多控制时，应使用CharsetDecoder类。
  
  参数:
  
  bytes - 要解码为字符的字节
  
  charsetName - 支持的字符集的名称
  
  抛出:
  
  UnsupportedEncodingException - 如果命名的字符集不受支持
  
  自:
  
  1.1
- String
  
  public String(byte[] bytes, Charset charset)
  
  通过使用指定字符集解码字节数组来构造一个新的String。新String的长度取决于字符集，因此可能不等于字节数组的长度。
  此方法始终使用此字符集的默认替换字符串替换格式错误的输入和无法映射的字符序列。当需要对解码过程进行更多控制时，应使用CharsetDecoder类。
  
  参数:
  
  bytes - 要解码为字符的字节
  
  charset - 用于解码bytes的字符集
  
  自:
  
  1.6
- String
  
  public String(byte[] bytes, int offset, int length)
  
  通过使用默认字符集解码字节数组的指定子数组来构造一个新的String。新String的长度取决于字符集，因此可能不等于子数组的长度。
  当给定的字节在默认字符集中无效时，此构造函数的行为是未指定的。当需要对解码过程进行更多控制时，应使用CharsetDecoder类。
  
  参数:
  
  bytes - 要解码为字符的字节
  
  offset - 要解码的第一个字节的索引
  
  length - 要解码的字节数
  
  抛出:
  
  IndexOutOfBoundsException - 如果offset为负、length为负或offset大于bytes.length - length
  
  自:
  
  1.1
- String
  
  public String(byte[] bytes)
  
  通过使用默认字符集解码字节数组来构造一个新的String。新String的长度取决于字符集，因此可能不等于字节数组的长度。
  当给定的字节在默认字符集中无效时，此构造函数的行为是未指定的。当需要对解码过程进行更多控制时，应使用CharsetDecoder类。
  
  参数:
  
  bytes - 要解码为字符的字节
  
  自:
  
  1.1
- String
  
  public String(StringBuffer buffer)
  
  分配一个新的字符串，其中包含当前包含在字符串缓冲区参数中的字符序列。字符串缓冲区的内容将被复制；随后对字符串缓冲区的修改不会影响新创建的字符串。
  
  参数:
  
  buffer - 一个StringBuffer
- String
  
  public String(StringBuilder builder)
  
  分配一个新的字符串，其中包含当前包含在字符串构建器参数中的字符序列。字符串构建器的内容将被复制；随后对字符串构建器的修改不会影响新创建的字符串。
  提供此构造函数是为了便于迁移到 StringBuilder。通过 toString方法从字符串构建器获取字符串可能运行更快，通常更受欢迎。
  
  参数:
  
  builder - 一个StringBuilder
  
  自:
  
  1.5

Method Details

length

public int length()

返回此字符串的长度。长度等于字符串中的Unicode代码单元数。

指定者:

length 在接口 CharSequence

返回:

此对象表示的字符序列的长度。
isEmpty

public boolean isEmpty()

如果且仅当length()为0时返回true。

指定者:

isEmpty 在接口 CharSequence中

返回值:

如果length()为0，则返回true，否则返回false

自版本:

1.6
charAt

public char charAt(int index)

返回指定索引处的char值。索引范围从0到length() - 1。序列的第一个char值在索引0处，下一个在索引1处，依此类推，就像数组索引一样。
如果索引指定的char值是一个代理项，则返回代理值。

指定者:

charAt 在接口 CharSequence中

参数:

index - char值的索引

返回值:

返回此字符串中指定索引处的char值。第一个char值在索引0处。

抛出:

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

public int codePointAt(int index)

返回指定索引处的字符（Unicode代码点）。索引是指char值（Unicode代码单元），范围从0到length() - 1。
如果给定索引处的char值在高代理项范围内，并且以下索引小于此String的长度，并且以下索引处的char值在低代理项范围内，则返回对应于此代理对的补充代码点。否则，返回给定索引处的char值。

参数:

index - char值的索引

返回值:

给定索引处字符的代码点值

抛出:

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

自版本:

1.5
codePointBefore

public int codePointBefore(int index)

返回指定索引之前的字符（Unicode代码点）。索引是指char值（Unicode代码单元），范围从1到length。
如果(index - 1)处的char值在低代理项范围内，(index - 2)不为负数，并且(index - 2)处的char值在高代理项范围内，则返回代理对的补充代码点值。如果index - 1处的char值是不成对的低代理项或高代理项，则返回代理值。

参数:

index - 应返回其前面代码点的索引

返回值:

给定索引之前的Unicode代码点值

抛出:

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

自版本:

1.5
codePointCount

public int codePointCount(int beginIndex, int endIndex)

返回此String的指定文本范围内的Unicode代码点数。文本范围从指定的beginIndex开始，延伸到索引endIndex - 1处的char。因此，文本范围（以char为单位）为endIndex-beginIndex。文本范围内的不成对代理项将计为一个代码点。

参数:

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

endIndex - 文本范围中最后一个char之后的索引

返回值:

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

抛出:

IndexOutOfBoundsException - 如果beginIndex为负数，或endIndex大于此String的长度，或beginIndex大于endIndex。

自版本:

1.5
offsetByCodePoints

public int offsetByCodePoints(int index, int codePointOffset)

返回从给定index偏移codePointOffset代码点的索引。在由index和codePointOffset给出的文本范围内的不成对代理项将计为一个代码点。

参数:

index - 要偏移的索引

codePointOffset - 代码点的偏移量

返回值:

此String中的索引

抛出:

IndexOutOfBoundsException - 如果index为负数或大于此String的长度，或者如果codePointOffset为正数且以index开头的子字符串的代码点少于codePointOffset，或者如果codePointOffset为负数且以index之前的子字符串的代码点少于codePointOffset的绝对值。

自版本:

1.5
getChars

public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组中。
要复制的第一个字符位于索引srcBegin处；要复制的最后一个字符位于索引srcEnd-1处（因此要复制的字符总数为srcEnd-srcBegin）。字符被复制到从索引dstBegin开始到索引结束的dst的子数组中：
```
     dstBegin + (srcEnd-srcBegin) - 1
 
```
参数:

srcBegin - 要复制的字符串中第一个字符的索引

srcEnd - 要复制的字符串中最后一个字符之后的索引

dst - 目标数组

dstBegin - 目标数组中的起始偏移量

抛出:
IndexOutOfBoundsException - 如果以下任一情况为真：
- srcBegin为负数。
- srcBegin大于srcEnd
- srcEnd大于此字符串的长度
- dstBegin为负数
- dstBegin+(srcEnd-srcBegin)大于dst.length
getBytes

@Deprecated(since="1.1") public void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)

Deprecated.
This method does not properly convert characters into bytes. As of JDK 1.1, the preferred way to do this is via the getBytes() method, which uses the default charset.
将字符从此字符串复制到目标字节数组中。每个字节接收相应字符的8个低位。每个字符的8个高位不会被复制，也不会以任何方式参与传输。
要复制的第一个字符位于索引srcBegin处；要复制的最后一个字符位于索引srcEnd-1处。要复制的字符总数为srcEnd-srcBegin。将转换为字节的字符被复制到从索引dstBegin开始到索引结束的dst的子数组中：
```
     dstBegin + (srcEnd-srcBegin) - 1
 
```
参数:

srcBegin - 要复制的字符串中第一个字符的索引

srcEnd - 要复制的字符串中最后一个字符之后的索引

dst - 目标数组

dstBegin - 目标数组中的起始偏移量

抛出:
IndexOutOfBoundsException - 如果以下任一情况为真：
- srcBegin为负数
- srcBegin大于srcEnd
- srcEnd大于此字符串的长度
- dstBegin为负数
- dstBegin+(srcEnd-srcBegin)大于dst.length
getBytes

public byte[] getBytes(String charsetName) throws UnsupportedEncodingException

使用指定的字符集将此String编码为字节序列，并将结果存储到新的字节数组中。
当无法使用给定字符集对此字符串进行编码时，此方法的行为是未指定的。当需要对编码过程进行更多控制时，应使用CharsetEncoder类。

参数:

charsetName - 支持的字符集的名称

返回值:

结果字节数组

抛出:

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

自版本:

1.1
getBytes

public byte[] getBytes(Charset charset)

使用给定的字符集将此String编码为字节序列，并将结果存储到新的字节数组中。
此方法始终使用此字符集的默认替换字节数组替换格式不正确的输入和无法映射的字符序列。当需要对编码过程进行更多控制时，应使用CharsetEncoder类。

参数:

charset - 用于对String进行编码的Charset

返回值:

结果字节数组

自版本:

1.6
getBytes

public byte[] getBytes()

使用默认字符集将此String编码为字节序列，并将结果存储到新的字节数组中。
当无法使用默认字符集对此字符串进行编码时，此方法的行为是未指定的。当需要对编码过程进行更多控制时，应使用CharsetEncoder类。

返回:

结果字节数组

自1.1版本起:

1.1
equals

public boolean equals(Object anObject)

将此字符串与指定对象进行比较。结果仅在参数不为null且为表示与此对象相同字符序列的String对象时为true。
要进行更精细的字符串比较，请参考Collator。
覆盖:

equals 在类 Object中

参数:

anObject - 要与此String进行比较的对象

返回:

如果给定对象表示与此字符串等效的String，则返回true；否则返回false

另请参阅:
- compareTo(String)
- equalsIgnoreCase(String)
contentEquals

public boolean contentEquals(StringBuffer sb)

将此字符串与指定的StringBuffer进行比较。结果仅在此String表示与指定的StringBuffer相同字符序列时为true。此方法在StringBuffer上同步。
要进行更精细的字符串比较，请参考Collator。

参数:

sb - 要与此String进行比较的StringBuffer

返回:

如果此String表示与指定的StringBuffer相同字符序列，则返回true；否则返回false

自1.4版本起:

1.4
contentEquals

public boolean contentEquals(CharSequence cs)

将此字符串与指定的CharSequence进行比较。结果仅在此String表示与指定序列相同的字符值序列时为true。请注意，如果CharSequence是StringBuffer，则该方法会在其上同步。
要进行更精细的字符串比较，请参考Collator。

参数:

cs - 要与此String进行比较的序列

返回:

如果此String表示与指定序列相同的字符值序列，则返回true；否则返回false

自1.5版本起:

1.5
equalsIgnoreCase

public boolean equalsIgnoreCase(String anotherString)
将此String与另一个String进行比较，忽略大小写。如果两个字符串在忽略大小写的情况下被认为相等，则它们的长度相同且两个字符串中对应的Unicode代码点在忽略大小写时相等。
如果以下至少一项为真，则两个Unicode代码点在忽略大小写时被认为相同：
- 两个Unicode代码点相同（通过==运算符比较）
- 对每个Unicode代码点调用Character.toLowerCase(Character.toUpperCase(int))会产生相同结果
请注意，此方法不考虑区域设置，对于某些区域设置可能会导致不满意的结果。类Collator提供区域设置敏感的比较。
参数:

anotherString - 要与此String进行比较的String

返回:

如果参数不为null且表示一个在忽略大小写时等效的String，则返回true；否则返回false

另请参阅:
- equals(Object)
- codePoints()
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()
 
```
要进行更精细的字符串比较，请参考Collator。
指定者:

compareTo 在接口 Comparable<String>中

参数:

anotherString - 要比较的String

返回:

如果参数字符串等于此字符串，则返回值0；如果此字符串按字典顺序小于字符串参数，则返回小于0的值；如果此字符串按字典顺序大于字符串参数，则返回大于0的值。
compareToIgnoreCase

public int compareToIgnoreCase(String str)

按字典顺序比较两个字符串，忽略大小写差异。此方法返回一个整数，其符号与使用消除了大小写差异的字符串的大小写版本调用compareTo的符号相同，其中通过对每个Unicode代码点调用Character.toLowerCase(Character.toUpperCase(int))来消除大小写差异。
请注意，此方法不考虑区域设置，对于某些区域设置可能会导致不满意的排序。类Collator提供区域设置敏感的比较。
参数:

str - 要比较的String

返回:

如果指定的字符串大于、等于或小于此字符串（忽略大小写考虑），则返回负整数、零或正整数。

自1.2版本起:

1.2

另请参阅:
- Collator
- codePoints()
regionMatches

public boolean regionMatches(int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
将此String对象的子字符串与参数other的子字符串进行比较。如果这些子字符串表示相同的字符序列，则结果为true。要比较的此String对象的子字符串从索引toffset开始，长度为len。要比较的其他子字符串从索引ooffset开始，长度为len。如果以下至少一项为真，则结果为false：
- toffset为负数。
- ooffset为负数。
- toffset+len大于此String对象的长度。
- ooffset+len大于其他参数的长度。
- 存在某个小于len的非负整数k，使得：this.charAt(toffset + k) != other.charAt(ooffset + k)
请注意，此方法不考虑区域设置。类Collator提供区域设置敏感的比较。
参数:

toffset - 要比较的子区域在此字符串中的起始偏移量。

other - 字符串参数。

ooffset - 字符串参数中子区域的起始偏移量。

len - 要比较的字符数。

返回:

如果此字符串的指定子区域与字符串参数的指定子区域完全匹配，则返回true；否则返回false。
regionMatches

public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
检测两个字符串区域是否相等。
将此String对象的子字符串与参数other的子字符串进行比较。如果这些子字符串表示相同的Unicode代码点序列，则结果为true，仅当ignoreCase为true时忽略大小写。比较序列tsequence和osequence，其中tsequence是通过调用this.substring(toffset, toffset + len).codePoints()生成的序列，osequence是通过调用other.substring(ooffset, ooffset + len).codePoints()生成的序列。结果为true仅当以下所有条件都为真时：
- toffset为非负数。
- ooffset为非负数。
- toffset+len小于或等于此String对象的长度。
- ooffset+len小于或等于另一个参数的长度。
- 如果ignoreCase为false，则所有对应的Unicode代码点对都是相等的整数值；或者如果ignoreCase为true，则所有Unicode代码点对上的Character.toLowerCase( Character.toUpperCase(int))的结果是相等的整数值。
请注意，此方法不考虑区域设置，并且在ignoreCase为true时，对于某些区域设置将导致不满意的结果。 Collator类提供区域设置敏感的比较。
参数：

ignoreCase - 如果为true，则在比较字符时忽略大小写。

toffset - 此字符串中子区域的起始偏移量。

other - 字符串参数。

ooffset - 字符串参数中子区域的起始偏移量。

len - 要比较的字符数（Unicode代码单元 - 16位char值）。

返回：

如果此字符串的指定子区域与字符串参数的指定子区域匹配，则为true；否则为false。匹配是精确匹配还是不区分大小写取决于ignoreCase参数。

参见：
- codePoints()
startsWith

public boolean startsWith(String prefix, int toffset)

检查从指定索引开始的此字符串的子字符串是否以指定前缀开头。
参数：

prefix - 前缀。

toffset - 在此字符串中开始查找的位置。

返回：
如果由参数表示的字符序列是从索引toffset开始的此对象的子字符串的前缀，则为true；否则为false。如果toffset为负数或大于此String对象的长度，则结果为false；否则结果与表达式的结果相同
```
          this.substring(toffset).startsWith(prefix)
          
```
startsWith

public boolean startsWith(String prefix)

检查此字符串是否以指定前缀开头。

参数：

prefix - 前缀。

返回：

如果由参数表示的字符序列是此字符串表示的字符序列的前缀，则为true；否则为false。还请注意，如果参数是空字符串或根据equals(Object)方法确定等于此String对象，则将返回true。

自：

1.0
endsWith

public boolean endsWith(String suffix)

检查此字符串是否以指定后缀结尾。

参数：

suffix - 后缀。

返回：

如果由参数表示的字符序列是此对象表示的字符序列的后缀，则为true；否则为false。请注意，如果参数是空字符串或根据equals(Object)方法确定等于此String对象，则结果将为true。
hashCode

public int hashCode()
返回此字符串的哈希码。 String对象的哈希码计算为
```
 s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
 
```
使用int算术，其中s[i]是字符串的第i个字符，n是字符串的长度，^表示指数。（空字符串的哈希值为零。）
覆盖：

hashCode 在类 Object

返回：

此对象的哈希码值。

参见：
- Object.equals(java.lang.Object)
- System.identityHashCode(java.lang.Object)
indexOf

public int indexOf(int ch)
返回指定字符第一次出现在此字符串中的索引。如果此String对象表示的字符序列中存在值为ch的字符，则返回第一个出现的位置的索引（以Unicode代码单元表示）。对于范围从0到0xFFFF（包括）的ch值，这是最小值k，使得：
```
 this.charAt(k) == ch
 
```
为真。对于其他ch值，这是最小值k，使得：
```
 this.codePointAt(k) == ch
 
```
为真。在任一情况下，如果此字符串中不存在该字符，则返回-1。
参数：

ch - 字符（Unicode代码点）。

返回：

该字符在此对象表示的字符序列中的第一次出现的索引，如果字符不存在，则返回-1。
indexOf

public int indexOf(int ch, int fromIndex)
返回指定字符第一次出现在此字符串中的索引，从指定索引开始搜索。
如果此String对象表示的字符序列中值为ch的字符出现在不小于fromIndex的索引处，则返回第一个出现的位置的索引。对于范围从0到0xFFFF（包括）的ch值，这是最小值k，使得：
```
 (this.charAt(k) == ch) && (k >= fromIndex)
 
```
为真。对于其他ch值，这是最小值k，使得：
```
 (this.codePointAt(k) == ch) && (k >= fromIndex)
 
```
为真。在任一情况下，如果此字符串中在fromIndex位置或之后不存在该字符，则返回-1。
fromIndex的值没有限制。如果为负数，则其效果与为零相同：可以搜索整个字符串。如果大于此字符串的长度，则其效果与等于此字符串的长度相同：返回-1。

所有索引都以char值（Unicode代码单元）指定。
API注释：

与substring(int)等方法不同，当fromIndex超出有效范围时，此方法不会抛出异常。相反，当fromIndex大于字符串长度时，返回-1。该结果本身无法与字符串中真正缺少ch的情况区分开。如果需要更严格的行为，则应考虑使用indexOf(int, int, int)。例如，在String s上，如果fromIndex大于字符串长度或为负数，则s.indexOf(ch, fromIndex, s.length())将抛出异常。

参数：

ch - 字符（Unicode代码点）。

fromIndex - 开始搜索的索引。

返回：

该对象表示的字符序列中第一次出现的字符的索引，大于或等于fromIndex，如果字符不存在，则返回-1。
indexOf

public int indexOf(int ch, int beginIndex, int endIndex)
返回指定字符第一次出现在此字符串中的索引，从beginIndex开始搜索，停止在endIndex之前。
如果此String对象表示的字符序列中值为ch的字符出现在不小于beginIndex但小于endIndex的索引处，则返回第一个出现的位置的索引。对于范围从0到0xFFFF（包括）的ch值，这是最小值k，使得：
```
 (this.charAt(k) == ch) && (beginIndex <= k < endIndex)
 
```
为真。对于其他ch值，这是最小值k，使得：
```
 (this.codePointAt(k) == ch) && (beginIndex <= k < endIndex)
 
```
为真。在任一情况下，如果此字符串中在beginIndex位置或之后且在endIndex位置之前不存在该字符，则返回-1。
所有索引都以char值（Unicode代码单元）指定。
参数：

ch - 字符（Unicode代码点）。

beginIndex - 开始搜索的索引（包括）。

endIndex - 停止搜索的索引（不包括）。

返回：

该对象表示的字符序列中第一次出现的字符的索引，大于或等于beginIndex且小于endIndex，如果字符不存在，则返回-1。

抛出：

StringIndexOutOfBoundsException - 如果beginIndex为负数，或endIndex大于此String对象的长度，或beginIndex大于endIndex。

自：

21
lastIndexOf

public int lastIndexOf(int ch)
返回指定字符在此字符串中最后一次出现的索引。对于范围从0到0xFFFF（包括）的ch值，返回的索引（以Unicode代码单元表示）是最大值k，使得：
```
 this.charAt(k) == ch
 
```
为真。对于ch的其他值，返回的是最大值k，使得：
```
 this.codePointAt(k) == ch
 
```
为真。在任一情况下，如果此字符串中不存在该字符，则返回-1。从最后一个字符开始向后搜索字符串。
参数：

ch - 字符（Unicode代码点）。

返回：

该对象表示的字符序列中指定字符的最后一次出现的索引，如果字符不存在，则返回-1。
lastIndexOf

public int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现的索引，从指定索引开始向后搜索。对于范围从0到0xFFFF（包括）的ch值，返回的索引是最大值k，使得：
```
 (this.charAt(k) == ch) && (k <= fromIndex)
 
```
为真。对于ch的其他值，返回的是最大值k，使得：
```
 (this.codePointAt(k) == ch) && (k <= fromIndex)
 
```
为真。在任一情况下，如果在或在位置fromIndex之前的位置上不存在该字符，则返回-1。
所有索引都以char值（Unicode代码单元）指定。
参数：

ch - 字符（Unicode代码点）。

fromIndex - 开始搜索的索引。对fromIndex的值没有限制。如果大于或等于此字符串的长度，则其效果与等于此字符串长度减一相同：可以搜索整个字符串。如果为负，则其效果与-1相同：返回-1。

返回：

该对象表示的字符序列中指定字符的最后一次出现的索引，小于或等于fromIndex，如果字符在该点之前不存在，则返回-1。
indexOf

public int indexOf(String str)
返回指定子字符串在此字符串中第一次出现的索引。
返回的索引是最小值k，满足以下条件：
```
 this.startsWith(str, k)
 
```
如果不存在这样的k值，则返回-1。
参数：

str - 要搜索的子字符串。

返回：

指定子字符串的第一次出现的索引，如果没有这样的出现，则返回-1。
indexOf

public int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现的索引，从指定索引开始。
返回的索引是最小值k，满足以下条件：
```
     k >= Math.min(fromIndex, this.length()) &&
                   this.startsWith(str, k)
 
```
如果不存在这样的k值，则返回-1。
API注释：

与substring(int)等方法不同，当fromIndex超出有效范围时，此方法不会抛出异常。相反，当fromIndex大于字符串长度时，它会返回-1。这个结果本身无法区分字符串中是否真正缺少str。如果需要更严格的行为，则应考虑使用indexOf(String, int, int)。例如，在非空str和String s上，s.indexOf(str, fromIndex, s.length())如果fromIndex大于字符串长度或为负数，则会抛出异常。

参数：

str - 要搜索的子字符串。

fromIndex - 开始搜索的索引。

返回：

指定子字符串的第一次出现的索引，从指定索引开始，如果没有这样的出现，则返回-1。
indexOf

public int indexOf(String str, int beginIndex, int endIndex)
返回指定索引范围内this字符串中指定子字符串的第一次出现的索引。
如果indexOf(String)返回的索引是非负数，则此方法返回与以下调用结果相同
```
     s.substring(beginIndex, endIndex).indexOf(str) + beginIndex
 
```
否则返回-1。（不会实例化子字符串。）
参数：

str - 要搜索的子字符串。

beginIndex - 开始搜索的索引（包括）。

endIndex - 停止搜索的索引（不包括）。

返回：

指定索引范围内指定子字符串的第一次出现的索引，如果没有这样的出现，则返回-1。

抛出：

StringIndexOutOfBoundsException - 如果beginIndex为负数，或endIndex大于此String对象的长度，或beginIndex大于endIndex。

自：

21
lastIndexOf

public int lastIndexOf(String str)
返回指定子字符串在此字符串中最后一次出现的索引。空字符串""的最后一次出现被认为发生在索引值this.length()处。
返回的索引是最大值k，满足以下条件：
```
 this.startsWith(str, k)
 
```
如果不存在这样的k值，则返回-1。
参数：

str - 要搜索的子字符串。

返回：

指定子字符串的最后一次出现的索引，如果没有这样的出现，则返回-1。
lastIndexOf

public int lastIndexOf(String str, int fromIndex)
返回指定子字符串在此字符串中最后一次出现的索引，从指定索引开始向后搜索。
返回的索引是最大值k，满足以下条件：
```
     k <= Math.min(fromIndex, this.length()) &&
                   this.startsWith(str, k)
 
```
如果不存在这样的k值，则返回-1。
参数：

str - 要搜索的子字符串。

fromIndex - 开始搜索的索引。

返回：

指定子字符串的最后一次出现的索引，从指定索引开始向后搜索，如果没有这样的出现，则返回-1。
substring

public String substring(int beginIndex)
返回此字符串的子字符串。子字符串从指定索引处的字符开始，一直延伸到此字符串的末尾。
示例：
```
 "unhappy".substring(2) 返回 "happy"
 "Harbison".substring(3) 返回 "bison"
 "emptiness".substring(9) 返回 ""（空字符串）
 
```
参数：

beginIndex - 起始索引，包括在内。

返回：

指定的子字符串。

抛出：

IndexOutOfBoundsException - 如果beginIndex为负数或大于此String对象的长度。
substring

public String substring(int beginIndex, int endIndex)
返回此字符串的子字符串。子字符串从指定的beginIndex开始，一直延伸到索引endIndex - 1处的字符。因此，子字符串的长度为endIndex-beginIndex。
示例：
```
 "hamburger".substring(4, 8) 返回 "urge"
 "smiles".substring(1, 5) 返回 "mile"
 
```
参数：

beginIndex - 起始索引，包括在内。

endIndex - 结束索引，不包括在内。

返回：

指定的子字符串。

抛出：

IndexOutOfBoundsException - 如果beginIndex为负数，或endIndex大于此String对象的长度，或beginIndex大于endIndex。
subSequence

public CharSequence subSequence(int beginIndex, int endIndex)
返回此序列的子序列。
形式为
```
 str.subSequence(begin, end)
```
的此方法的调用行为与调用
```
 str.substring(begin, end)
```
的行为完全相同。
指定者：

subSequence 在接口 CharSequence中

API注释：

此方法的定义是为了String类可以实现CharSequence接口。

参数：

beginIndex - 起始索引，包括在内。

endIndex - 结束索引，不包括在内。

返回：

指定的子序列。

抛出：

IndexOutOfBoundsException - 如果beginIndex或endIndex为负数，如果endIndex大于length()，或者如果beginIndex大于endIndex

自：

1.4
concat

public String concat(String str)
将指定字符串连接到此字符串的末尾。
如果参数字符串的长度为0，则返回此String对象。否则，返回一个String对象，表示由此String对象表示的字符序列和参数字符串表示的字符序列连接而成的字符序列。

示例：
```
 "cares".concat("s") 返回 "caress"
 "to".concat("get").concat("her") 返回 "together"
 
```
参数:

str - 要连接到此 String 末尾的 String。

返回值:

一个字符串，表示此对象的字符连接后跟字符串参数的字符。
replace

public String replace(char oldChar, char newChar)
返回一个字符串，其中替换此字符串中所有出现的 oldChar 为 newChar。
如果字符 oldChar 不在此 String 对象表示的字符序列中，则返回对此 String 对象的引用。否则，返回一个表示与此 String 对象表示的字符序列相同的字符序列，除了每个 oldChar 的出现都被 newChar 的出现替换。

示例:
```
 "mesquite in your cellar".replace('e', 'o')
         返回 "mosquito in your collar"
 "the war of baronets".replace('r', 'y')
         返回 "the way of bayonets"
 "sparring with a purple porpoise".replace('p', 't')
         返回 "starring with a turtle tortoise"
 "JonL".replace('q', 'x') 返回 "JonL" (无变化)
 
```
参数:

oldChar - 旧字符。

newChar - 新字符。

返回值:

通过用 newChar 替换每个 oldChar 而派生的字符串。
matches

public boolean matches(String regex)

告知此字符串是否与给定的正则表达式匹配。
以 str.matches(regex)形式调用此方法的结果与表达式

Pattern.matches(regex, str)
相同。
参数:

regex - 要匹配的正则表达式

返回值:

如果且仅当此字符串与给定的正则表达式匹配时为 true

抛出:

PatternSyntaxException - 如果正则表达式的语法无效

自:

1.4

参见:
- Pattern
contains

public boolean contains(CharSequence s)

如果此字符串包含指定的字符值序列，则返回 true。

参数:

s - 要搜索的序列

返回值:

如果此字符串包含 s，则返回 true，否则返回 false

自:

1.5
replaceFirst

public String replaceFirst(String regex, String replacement)

用给定的正则表达式匹配的第一个子字符串替换为给定的替换字符串。
以 str.replaceFirst(regex, repl)形式调用此方法的结果与表达式

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

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

regex - 要匹配的正则表达式

replacement - 要替换第一个匹配项的字符串

返回值:

结果的 String

抛出:

PatternSyntaxException - 如果正则表达式的语法无效

自:

1.4

参见:
- Pattern
replaceAll

public String replaceAll(String regex, String replacement)

用给定的正则表达式匹配的每个子字符串替换为给定的替换字符串。
以 str.replaceAll(regex, repl)形式调用此方法的结果与表达式

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

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

regex - 要匹配的正则表达式

replacement - 要替换每个匹配项的字符串

返回值:

结果的 String

抛出:

PatternSyntaxException - 如果正则表达式的语法无效

自:

1.4

参见:
- Pattern
replace

public String replace(CharSequence target, CharSequence replacement)

用指定的字面目标序列匹配的每个子字符串替换为指定的字面替换序列。替换从字符串的开头到结尾进行，例如，在字符串 "aaa" 中用 "aa" 替换 "b" 将得到 "ba" 而不是 "ab"。

参数:

target - 要替换的字符值序列

replacement - 替换的字符值序列

返回值:

结果字符串

自:

1.5

split

public String[] split(String regex, int limit)

围绕给定的正则表达式匹配拆分此字符串。

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

当此字符串开头有正向宽度匹配时，结果数组的开头将包含一个空的前导子字符串。然而，开头的零宽度匹配永远不会产生这样的空前导子字符串。

limit 参数控制模式应用的次数，因此影响结果数组的长度。

如果 limit 为正数，则模式最多应用 limit - 1 次，数组的长度不会大于 limit，数组的最后一个条目将包含最后一个匹配定界符之后的所有输入。
如果 limit 为零，则模式将尽可能多地应用，数组可以具有任何长度，并且将丢弃尾随的空字符串。
如果 limit 为负数，则模式将尽可能多地应用，数组可以具有任何长度。

例如，字符串 "boo:and:foo" 使用这些参数将产生以下结果:

拆分示例显示正则表达式、限制和结果

正则表达式限制结果

: 2 { "boo", "and:foo" }

5 { "boo", "and", "foo" }

-2 { "boo", "and", "foo" }

o 5 { "b", "", ":and:f", "", "" }

-2 { "b", "", ":and:f", "", "" }

0 { "b", "", ":and:f" }

以 str.split(regex, n)形式调用此方法的结果与表达式

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

相同。

参数:

regex - 分隔正则表达式

limit - 结果阈值，如上所述

返回:

通过在给定正则表达式的匹配项周围拆分此字符串而计算的字符串数组

抛出:

PatternSyntaxException - 如果正则表达式的语法无效

自:

1.4

参见:

splitWithDelimiters

public String[] splitWithDelimiters(String regex, int limit)

拆分此字符串以匹配给定正则表达式的匹配项，并返回字符串和匹配定界符。

此方法返回的数组包含由另一个与给定表达式匹配的子字符串终止或由字符串末尾终止的每个此字符串的子字符串。每个子字符串后面紧跟着与给定表达式匹配的子序列（定界符），除了最后一个子字符串，它后面没有任何内容。数组中的子字符串和定界符的顺序与它们在输入中出现的顺序相同。如果表达式不匹配输入的任何部分，则结果数组只有一个元素，即此字符串。

limit参数控制模式应用的次数，因此影响结果数组的长度。

如果limit为正数，则模式最多应用limit - 1次，数组的长度不会大于2 × limit - 1，并且数组的最后一个条目将包含最后匹配定界符之后的所有输入。
如果limit为零，则模式将尽可能多次应用，数组可以具有任何长度，并且将丢弃尾随的空字符串。
如果limit为负数，则模式将尽可能多次应用，数组可以具有任何长度。

例如，输入"boo:::and::foo"，使用这些参数将产生以下结果：

显示正则表达式、限制和结果的拆分示例
正则表达式	限制	结果
:+	2	`{ "boo", ":::", "and::foo" }`
	5	`{ "boo", ":::", "and", "::", "foo" }`
	-1	`{ "boo", ":::", "and", "::", "foo" }`
o	5	`{ "b", "o", "", "o", ":::and::f", "o", "", "o", "" }`
	-1	`{ "b", "o", "", "o", ":::and::f", "o", "", "o", "" }`
	0	`{ "b", "o", "", "o", ":::and::f", "o", "", "o" }`

API 注意:: 以 str.splitWithDelimiters(regex, n) 形式调用此方法将产生与表达式相同的结果
Pattern.compile(regex).splitWithDelimiters(str, n)
参数:: regex - 定界正则表达式; limit - 如上所述的结果阈值
返回:: 通过在给定正则表达式的匹配项周围拆分此字符串而计算的字符串数组，交替子字符串和匹配定界符
自:: 21

split

public String[] split(String regex)

拆分此字符串以匹配给定正则表达式的匹配项。

此方法的工作方式类似于使用给定表达式和零限制参数调用两参数split方法。因此，尾随的空字符串不包括在结果数组中。

例如，字符串"boo:and:foo"，使用这些表达式将产生以下结果：

显示正则表达式和结果的拆分示例

正则表达式结果

: { "boo", "and", "foo" }

o { "b", "", ":and:f" }

参数:

regex - 定界正则表达式

返回:

通过在给定正则表达式的匹配项周围拆分此字符串而计算的字符串数组

抛出:

PatternSyntaxException - 如果正则表达式的语法无效

自:

1.4

参见:

join

public static String join(CharSequence delimiter, CharSequence... elements)
返回一个由CharSequence元素的副本与指定delimiter的副本连接在一起的新字符串。
例如，
```
     String message = String.join("-", "Java", "is", "cool");
     // 返回的消息是: "Java-is-cool"
 
```
请注意，如果元素为null，则添加"null"。
参数:

delimiter - 分隔每个元素的定界符

elements - 要连接在一起的元素。

返回:

由elements用delimiter分隔的新String

抛出:

NullPointerException - 如果delimiter或elements为null

自:

1.8

参见:
- StringJoiner
join

public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)
返回一个由CharSequence元素的副本与指定delimiter的副本连接在一起的新String。
例如，
```
     List<String> strings = List.of("Java", "is", "cool");
     String message = String.join(" ", strings);
     // 返回的消息是: "Java is cool"

     Set<String> strings =
         new LinkedHashSet<>(List.of("Java", "is", "very", "cool"));
     String message = String.join("-", strings);
     // 返回的消息是: "Java-is-very-cool"
 
```
请注意，如果单个元素为null，则添加"null"。
参数:

delimiter - 用于分隔结果String中的每个elements的字符序列

elements - 将连接在一起的elements的Iterable。

返回:

由elements参数组成的新String

抛出:

NullPointerException - 如果delimiter或elements为null

自:

1.8

参见:
- join(CharSequence,CharSequence...)
- StringJoiner

toLowerCase

public String toLowerCase(Locale locale)

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

小写映射的示例在以下表中：

显示具有区域设置的语言代码、大写、小写和描述的小写映射示例
区域设置的语言代码	大写	小写	描述
tr (土耳其语)	\u0130	\u0069	带点的大写字母I -> 小写字母i
tr (土耳其语)	\u0049	\u0131	大写字母I -> 无点小写i
(所有)	French Fries	french fries	字符串中的所有字符转换为小写
(所有)	ΙΧΘΥΣ	ιχθυσ	字符串中的所有字符转换为小写

参数:

locale - 使用此区域设置的大小写转换规则

返回值:

转换为小写的String。

自版本:

1.1

参见:

toLowerCase

public String toLowerCase()

使用默认区域设置的规则将此String中的所有字符转换为小写。此方法等效于toLowerCase(Locale.getDefault())。
API 注释:

此方法是区域敏感的，如果用于预期独立于区域设置解释的字符串，可能会产生意外结果。示例包括编程语言标识符、协议键和HTML标记。例如，在土耳其区域设置中，"TITLE".toLowerCase()返回"t\u0131tle"，其中'\u0131'是拉丁小写无点I字符。要获取区域设置无关字符串的正确结果，请使用toLowerCase(Locale.ROOT)。

返回值:

转换为小写的String。

参见:
- toLowerCase(Locale)

toUpperCase

public String toUpperCase(Locale locale)

使用给定Locale的规则将此String中的所有字符转换为大写。大小写映射基于由Character类指定的Unicode标准版本。由于大小写映射并非始终是1:1字符映射，因此结果的String和此String可能在长度上有所不同。

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

区域敏感和1:M大小写映射示例。显示区域的语言代码、小写、大写和描述。
区域的语言代码	小写	大写	描述
tr (土耳其)	\u0069	\u0130	小写i -> 带点的大写I
tr (土耳其)	\u0131	\u0049	无点小写i -> 大写I
(所有)	\u00df	\u0053 \u0053	尖s -> 两个字母: SS
(所有)	Fahrvergnügen	FAHRVERGNÜGEN

参数:

locale - 使用此区域设置的大小写转换规则

返回值:

转换为大写的String。

自版本:

1.1

参见:

toUpperCase

public String toUpperCase()

使用默认区域设置的规则将此String中的所有字符转换为大写。此方法等效于toUpperCase(Locale.getDefault())。
API 注释:

此方法是区域敏感的，如果用于预期独立于区域设置解释的字符串，可能会产生意外结果。示例包括编程语言标识符、协议键和HTML标记。例如，在土耳其区域设置中，"title".toUpperCase()返回"T\u0130TLE"，其中'\u0130'是拉丁带点大写I字符。要获取区域设置无关字符串的正确结果，请使用toUpperCase(Locale.ROOT)。

返回值:

转换为大写的String。

参见:
- toUpperCase(Locale)
trim

public String trim()

返回一个值为此字符串的值，其中移除了所有前导和尾随空格，其中空格定义为其代码点小于或等于'U+0020'（空格字符）的任何字符。
如果此String对象表示空字符序列，或者由此String对象表示的字符序列的第一个和最后一个字符的代码不是空格（如上定义），则返回对此String对象的引用。

否则，如果此字符串中的所有字符都是空格（如上定义），则返回表示空字符串的String对象。

否则，让k为字符串中第一个代码不是空格（如上定义）的字符的索引，让m为字符串中最后一个代码不是空格（如上定义）的字符的索引。返回一个String对象，表示从索引k处的字符开始，到索引m处的字符结束的子字符串-即，this.substring(k, m + 1)的结果。

此方法可用于修剪字符串开头和结尾的空格（如上定义）。

返回值:

一个值为此字符串的值，其中移除了所有前导和尾随空格，或者如果没有前导或尾随空格，则为此字符串。
strip

public String strip()

返回一个值为此字符串的值，其中移除了所有前导和尾随空白字符。
如果此String对象表示空字符串，或者此字符串中的所有代码点都是空白字符，则返回一个空字符串。

否则，返回一个从第一个不是空白字符的代码点开始，直到最后一个不是空白字符的代码点结束的子字符串。

此方法可用于从字符串开头和结尾剥离空白字符。
返回值:

一个值为此字符串的值，其中移除了所有前导和尾随空白字符

自版本:

11

参见:
- Character.isWhitespace(int)
stripLeading

public String stripLeading()

返回一个值为此字符串的值，其中移除了所有前导空白字符。
如果此String对象表示空字符串，或者此字符串中的所有代码点都是空白字符，则返回一个空字符串。

否则，返回一个从第一个不是空白字符的代码点开始，直到此字符串的最后一个代码点结束的子字符串。

此方法可用于从字符串开头修剪空白字符。
返回值:

一个值为此字符串的值，其中移除了所有前导空白字符

自版本:

11

参见:
- Character.isWhitespace(int)
stripTrailing

public String stripTrailing()

返回一个值为此字符串的值，其中移除了所有尾随空白字符。
如果此String对象表示空字符串，或者此字符串中的所有字符都是空白字符，则返回一个空字符串。

否则，返回一个从此字符串的第一个代码点开始，直到最后一个不是空白字符的代码点结束的子字符串。

此方法可用于从字符串结尾修剪空白字符。
返回值:

一个值为此字符串的值，其中移除了所有尾随空白字符

自版本:

11

参见:
- Character.isWhitespace(int)
isBlank

public boolean isBlank()

如果字符串为空或仅包含空白字符代码点，则返回true，否则返回false。
返回值:

如果字符串为空或仅包含空白字符代码点，则返回true，否则返回false

自版本:

11

参见:
- Character.isWhitespace(int)
lines

public Stream<String> lines()

返回从此字符串中提取的行的流，由行终止符分隔。
行终止符是以下之一：换行符字符"\n"（U+000A）、回车符字符"\r"（U+000D）或紧随回车符的换行符"\r\n"（U+000D U+000A）。

行是一个序列，由零个或多个字符后跟行终止符组成，或者是一个或多个字符后跟字符串结尾。行不包括行终止符。

此方法返回的流按照它们出现的顺序包含此字符串中的行。

API 注释:

此处对行的定义意味着空字符串具有零行，并且在字符串末尾的行终止符后没有空行。

实现注释:

通过提供元素的惰性提供和更快地搜索新行终止符，此方法提供了比split("\R")更好的性能。

返回值:

从此字符串中提取的行的流

自版本:

11
indent

public String indent(int n)

调整此字符串的每一行的缩进，基于n的值，并规范化行终止字符。
此字符串在使用lines()将其概念上分隔为行。然后，如下所述调整每行，然后以换行符"\n"（U+000A）结尾。然后连接结果行并返回。

如果n > 0，则在每行开头插入n个空格（U+0020）。

如果n < 0，则从每行开头最多删除n个空白字符。如果给定行不包含足够的空白字符，则删除所有前导空白字符。每个空白字符都被视为单个字符。特别地，制表符"\t"（U+0009）被视为单个字符；它不会被展开。

如果n == 0，则行保持不变。但是，行终止符仍然被规范化。
参数:

n - 要添加或删除的前导空白字符的数量

返回:

调整缩进并规范化行结束的字符串

自：

12

参见：
stripIndent

public String stripIndent()
返回一个值为此字符串的字符串，其中删除了每行开头和结尾的附加空格。
文本块中通常存在附加的空格，以使内容与开放分隔符对齐。例如，在以下代码中，点表示附加的空格：
```
 String html = """
 ..............<html>
 ..............    <body>
 ..............        <p>Hello, world</p>
 ..............    </body>
 ..............</html>
 ..............""";
 
```
此方法将附加的空格视为要删除的缩进，生成一个保留内容相对缩进的字符串。使用|可视化字符串的每行的开始：
```
 |<html>
 |    <body>
 |        <p>Hello, world</p>
 |    </body>
 |</html>
 
```
首先，提取此字符串的各行。一行是零个或多个字符序列，后跟换行符或字符串的结尾。如果字符串至少有一个换行符，则最后一行由最后一个换行符和字符串的结尾之间的字符组成。否则，如果字符串没有换行符，则最后一行是字符串的开头到字符串的结尾，换句话说，整个字符串。行不包括换行符。
然后，确定最小缩进（min）如下：
- 对于每个非空白行（由isBlank()定义），计算前导空格字符的数量。
- 即使空白，也会计算最后一行的前导空格字符的数量。
min值是这些计数中的最小值。

对于每个非空白行，删除min个前导空格字符，并删除任何尾随空格字符。空白行将替换为空字符串。

最后，使用LF字符"\n"（U+000A）将行连接成新字符串。
API注释：

此方法的主要目的是尽可能将一组行向左移动，同时保留相对缩进。因此，缩进最少的行将不包含前导空格。结果将具有与此字符串相同数量的行终止符。如果此字符串以行终止符结尾，则结果将以行终止符结尾。

实现要求：

此方法将所有空格字符视为具有相等宽度。只要每行的缩进始终由相同的字符序列组成，结果就将如上所述。

返回：

删除附加缩进并规范化行终止符的字符串

自：

15

参见：

translateEscapes

public String translateEscapes()

返回一个值为此字符串的字符串，其中转义序列被翻译为字符串文字中的样式。

转义序列翻译如下：

翻译
转义	名称	翻译
`\b`	退格	`U+0008`
`\t`	水平制表符	`U+0009`
`\n`	换行符	`U+000A`
`\f`	换页符	`U+000C`
`\r`	回车符	`U+000D`
`\s`	空格	`U+0020`
`\"`	双引号	`U+0022`
`\'`	单引号	`U+0027`
`\\`	反斜杠	`U+005C`
`\0 - \377`	八进制转义	代码点等效
`\<line-terminator>`	续行	丢弃

实现注释：: 此方法不会翻译Unicode转义，例如"\u2022"。Unicode转义是由Java编译器在读取输入字符时进行翻译的，并不是字符串文字规范的一部分。
返回：: 翻译了转义序列的字符串。
抛出：: IllegalArgumentException - 当转义序列格式不正确时。
参见Java语言规范：: 3.10.7 转义序列
自：: 15

transform

public <R> R transform(Function<? super String,? extends R> f)

此方法允许将函数应用于this字符串。该函数应该期望一个String参数并产生一个R结果。
由f.apply()抛出的任何异常将传播给调用者。
类型参数：

R - 结果的类型

参数：

f - 要应用的函数

返回：

将函数应用于此字符串的结果

自：

12

参见：
- Function
toString

public String toString()

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

指定者：

toString 在接口 CharSequence中

覆盖：

toString 在类 Object中

返回：

字符串本身。
chars

public IntStream chars()

返回一个流，从此序列中的char值零扩展。任何映射到代理代码点的字符都将不加解释地传递。

指定者：

chars 在接口 CharSequence中

返回：

从此序列中的char值的IntStream

自：

9
codePoints

public IntStream codePoints()

返回一个流，从此序列中的代码点值。在序列中遇到的代理对将被组合，就像通过Character.toCodePoint，并将结果传递给流。任何其他代码单元，包括普通BMP字符、未配对的代理和未定义的代码单元，都将被零扩展为int值，然后传递给流。

指定者：

codePoints 在接口 CharSequence中

返回：

从此序列中的Unicode代码点的IntStream

自：

9
toCharArray

public char[] toCharArray()

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

返回：

一个新分配的字符数组，其长度为此字符串的长度，并且其内容被初始化为包含此字符串表示的字符序列。
format

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

使用指定的格式字符串和参数返回格式化的字符串。
始终使用的区域设置是由Locale.getDefault(Locale.Category)返回的，指定了FORMAT类别。
参数:

format - 一个格式字符串

args - 格式字符串中格式说明符引用的参数。如果参数比格式说明符多，额外的参数将被忽略。参数的数量是可变的，可以为零。参数的最大数量受Java数组的最大维度限制，由Java虚拟机规范定义。对于null参数的行为取决于转换。

返回:

一个格式化的字符串

抛出:

IllegalFormatException - 如果格式字符串包含非法语法、与给定参数不兼容的格式说明符、给定格式字符串的参数不足或其他非法条件。有关所有可能的格式错误的规范，请参阅格式化程序类规范的详细信息部分。

自1.5版本起:

1.5

参见:
- Formatter
format

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

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

l - 要在格式化期间应用的区域设置。如果l为null，则不应用本地化。

format - 一个格式字符串

args - 格式字符串中格式说明符引用的参数。如果参数比格式说明符多，额外的参数将被忽略。参数的数量是可变的，可以为零。参数的最大数量受Java数组的最大维度限制，由Java虚拟机规范定义。对于null参数的行为取决于转换。

返回:

一个格式化的字符串

抛出:

IllegalFormatException - 如果格式字符串包含非法语法、与给定参数不兼容的格式说明符、给定格式字符串的参数不足或其他非法条件。有关所有可能的格式错误的规范，请参阅格式化程序类规范的详细信息部分

自1.5版本起:

1.5

参见:
- Formatter
formatted

public String formatted(Object... args)

使用此字符串作为格式字符串和提供的参数进行格式化。
实现要求:

此方法等效于String.format(this, args)。

参数:

args - 格式字符串中格式说明符引用的参数。

返回:

一个格式化的字符串

自15版本起:

15

参见:
- format(String,Object...)
- Formatter
valueOf

public static String valueOf(Object obj)

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

obj - 一个Object。

返回:

如果参数为null，则返回一个等于"null"的字符串；否则返回obj.toString()的值。

参见:
- Object.toString()
valueOf

public static String valueOf(char[] data)

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

参数:

data - 字符数组。

返回:

包含字符数组字符的String。
valueOf

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

返回char数组参数的特定子数组的字符串表示形式。
offset参数是子数组第一个字符的索引。count参数指定子数组的长度。子数组的内容将被复制；对字符数组的后续修改不会影响返回的字符串。

参数:

data - 字符数组。

offset - 子数组的初始偏移量。

count - 子数组的长度。

返回:

包含字符数组指定子数组的字符的String。

抛出:

IndexOutOfBoundsException - 如果offset为负数，或count为负数，或offset+count大于data.length。
copyValueOf

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

等效于valueOf(char[], int, int)。

参数:

data - 字符数组。

offset - 子数组的初始偏移量。

count - 子数组的长度。

返回:

包含字符数组指定子数组的字符的String。

抛出:

IndexOutOfBoundsException - 如果offset为负数，或count为负数，或offset+count大于data.length。
copyValueOf

public static String copyValueOf(char[] data)

等效于valueOf(char[])。

参数:

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参数的字符串表示形式。

参见:
- Integer.toString(int, int)
valueOf

public static String valueOf(long l)

返回long参数的字符串表示形式。
该表示形式与Long.toString方法的一个参数返回的表示形式完全相同。
参数:

l - 一个long。

返回:

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

参见:
- Long.toString(long)
valueOf

public static String valueOf(float f)

返回float参数的字符串表示形式。
该表示形式与Float.toString方法的一个参数返回的表示形式完全相同。
参数:

f - 一个float。

返回:

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

参见:
- Float.toString(float)
valueOf

public static String valueOf(double d)

返回double参数的字符串表示形式。
该表示形式与Double.toString方法的一个参数返回的表示形式完全相同。
参数:

d - 一个double。

返回:

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

参见:
- Double.toString(double)
intern

public String intern()

返回字符串对象的规范表示形式。
类String私有地维护一个最初为空的字符串池。

当调用intern方法时，如果池中已经包含一个与此String对象相等的字符串（由equals(Object)方法确定），则返回池中的字符串。否则，将此String对象添加到池中，并返回对此String对象的引用。

因此，对于任何两个字符串s和t，只有当s.equals(t)为true时，s.intern() == t.intern()才为true。

所有文字字符串和字符串值常量表达式都被池化。字符串文字在Java语言规范的第3.10.5节中定义。

返回:

一个具有与此字符串相同内容但保证来自唯一字符串池的字符串。
repeat

public String repeat(int count)

返回一个值为此字符串重复count次的字符串。
如果此字符串为空或count为零，则返回空字符串。

参数:

count - 重复次数

返回:

由此字符串重复count次组成的字符串，如果此字符串为空或计数为零，则返回空字符串

抛出:

IllegalArgumentException - 如果count为负数。

自:

11
describeConstable

public Optional<String> describeConstable()

返回一个包含此实例的名义描述符的Optional，即实例本身。

指定者:

describeConstable 在接口 Constable

返回:

一个描述String实例的Optional

自:

12
resolveConstantDesc

public String resolveConstantDesc(MethodHandles.Lookup lookup)

将此实例解析为ConstantDesc，其结果是实例本身。

指定者:

resolveConstantDesc 在接口 ConstantDesc

参数:

lookup - 忽略

返回:

String实例

自:

12

正则表达式	限制	结果
:	2	`{ "boo", "and:foo" }`
	5	`{ "boo", "and", "foo" }`
	-2	`{ "boo", "and", "foo" }`
o	5	`{ "b", "", ":and:f", "", "" }`
	-2	`{ "b", "", ":and:f", "", "" }`
	0	`{ "b", "", ":and:f" }`

Class String

Field Summary

Constructor Summary

Method Summary

Methods declared in class java.lang.Object

Field Details

CASE_INSENSITIVE_ORDER

Constructor Details

String

String

String

String

String

String

String

String

String

String

String

String

String

String

String

Method Details

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

indexOf

lastIndexOf

lastIndexOf

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

substring

substring

subSequence

concat

replace

matches

contains

replaceFirst

replaceAll

replace

split

splitWithDelimiters

split

join

join

toLowerCase

toLowerCase

toUpperCase

toUpperCase

trim

strip

stripLeading