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 格式的字符串，其中 supplementary characters 由 surrogate pairs 表示（有关详细信息，请参阅 Character 类中的 Unicode 字符表示部分）。索引值引用 char 代码单元，因此增补字符使用 String 中的两个位置。

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

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

实现注意事项：

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

看Java 语言规范:

15.18.1 字符串连接运算符 +

自从：

1.0

参见：

字段摘要

字段

修饰符和类型

Field

描述

static final Comparator<String>

CASE_INSENSITIVE_ORDER

按 compareToIgnoreCase 排序 String 对象的比较器。
构造方法总结

构造方法

构造方法

描述

String()

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

String(byte[] bytes)

通过使用 default charset 解码指定的字节数组来构造一个新的 String。

String(byte[] ascii, int hibyte)

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

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

通过使用 default charset 解码指定的字节子数组来构造一个新的 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)

通过使用指定的 charset 解码指定的字节子数组来构造一个新的 String。

String(byte[] bytes, String charsetName)

通过使用指定的 charset 解码指定的字节数组来构造一个新的 String。

String(byte[] bytes, Charset 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)

分配一个新字符串，其中包含当前包含在字符串生成器参数中的字符序列。
方法总结

修饰符和类型

方法

描述

char

charAt(int index)

返回指定索引处的 char 值。

IntStream

chars()

返回一个 int 流，对该序列的 char 值进行零扩展。

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)

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

String

formatted(Object... args)

使用此字符串作为格式字符串和提供的参数的格式。

byte[]

getBytes()

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

void

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

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

byte[]

getBytes(String charsetName)

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

byte[]

getBytes(Charset 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(String str)

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

int

indexOf(String str, int fromIndex)

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

String

intern()

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

boolean

isBlank()

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

boolean

isEmpty()

当且仅当 length() 是 0 时返回 true。

static String

join(CharSequence delimiter, CharSequence... elements)

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

static String

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

返回一个新的 String 由 CharSequence elements 的副本和指定的 delimiter 的副本组成。

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)

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

boolean

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

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

boolean

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

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

String

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)

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

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

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

String

toLowerCase(Locale locale)

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

String

toString()

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

String

toUpperCase()

使用默认locale的规则将此 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 参数的字符串表示形式。

在类 java.lang.Object 中声明的方法
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

字段详细信息
- CASE_INSENSITIVE_ORDER
  
  public static final Comparator <String > CASE_INSENSITIVE_ORDER
  
  按 compareToIgnoreCase 排序 String 对象的比较器。这个比较器是可序列化的。
  请注意，此比较器确实not考虑了locale，并且会导致某些locale的排序不令人满意。 Collator 类提供区域设置敏感的比较。
  自从：
  
  1.2
  
  参见：
  
  Collator
构造方法详细信息
- 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 参数指定子数组的长度。子数组的内容被转换为chars； 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)
  
  已弃用。
  此方法不能正确地将字节转换为字符。从 JDK 1.1 开始，首选方法是通过采用 Charset 字符集名称或使用 default charset 的 String 构造函数。
  
  分配一个由 8 位整数值数组的子数组构造的新 String。
  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)
  
  已弃用。
  此方法不能正确地将字节转换为字符。从 JDK 1.1 开始，首选方法是通过采用 Charset 字符集名称或使用 default charset 的 String 构造函数。
  分配一个新的 String 包含由 8 位整数值数组构造的字符。每个角色c结果字符串中的是从相应的组件构造的b在字节数组中这样：
  
  c == (char)(((hibyte & 0xff) << 8) | (b & 0xff))
  参数：
  
  ascii - 要转换为字符的字节
  
  hibyte - 每个 16 位 Unicode 代码单元的前 8 位
  
  参见：
  
  String(byte[], int, int, java.lang.String)
  
  String(byte[], int, int, 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 - 支持的名称 charset
  
  抛出：
  
  UnsupportedEncodingException - 如果不支持指定的字符集
  
  IndexOutOfBoundsException - 如果 offset 为负，length 为负，或者 offset 大于 bytes.length - length
  
  自从：
  
  1.1
- String
  
  public String(byte[] bytes, int offset, int length, Charset charset)
  
  通过使用指定的 charset 解码指定的字节子数组来构造一个新的 String。新 String 的长度是字符集的函数，因此可能不等于子数组的长度。
  此方法始终用此字符集的默认替换字符串替换格式错误的输入和不可映射的字符序列。当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。
  
  参数：
  
  bytes - 要解码为字符的字节
  
  offset - 要解码的第一个字节的索引
  
  length - 要解码的字节数
  
  charset - 用于解码 bytes 的 charset
  
  抛出：
  
  IndexOutOfBoundsException - 如果 offset 为负，length 为负，或者 offset 大于 bytes.length - length
  
  自从：
  
  1.6
- String
  
  public String(byte[] bytes, String charsetName) throws UnsupportedEncodingException
  
  通过使用指定的 charset 解码指定的字节数组来构造一个新的 String。新 String 的长度是字符集的函数，因此可能不等于字节数组的长度。
  当给定字节在给定字符集中无效时，此构造函数的行为未指定。当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。
  
  参数：
  
  bytes - 要解码为字符的字节
  
  charsetName - 支持的名称 charset
  
  抛出：
  
  UnsupportedEncodingException - 如果不支持指定的字符集
  
  自从：
  
  1.1
- String
  
  public String(byte[] bytes, Charset charset)
  
  通过使用指定的 charset 解码指定的字节数组来构造一个新的 String。新 String 的长度是字符集的函数，因此可能不等于字节数组的长度。
  此方法始终用此字符集的默认替换字符串替换格式错误的输入和不可映射的字符序列。当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。
  
  参数：
  
  bytes - 要解码为字符的字节
  
  charset - 用于解码 bytes 的 charset
  
  自从：
  
  1.6
- String
  
  public String(byte[] bytes, int offset, int length)
  
  通过使用 default charset 解码指定的字节子数组来构造一个新的 String。新 String 的长度是字符集的函数，因此可能不等于子数组的长度。
  当给定字节在默认字符集中无效时，此构造函数的行为未指定。当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。
  
  参数：
  
  bytes - 要解码为字符的字节
  
  offset - 要解码的第一个字节的索引
  
  length - 要解码的字节数
  
  抛出：
  
  IndexOutOfBoundsException - 如果 offset 为负，length 为负，或者 offset 大于 bytes.length - length
  
  自从：
  
  1.1
- String
  
  public String(byte[] bytes)
  
  通过使用 default charset 解码指定的字节数组来构造一个新的 String。新 String 的长度是字符集的函数，因此可能不等于字节数组的长度。
  当给定字节在默认字符集中无效时，此构造函数的行为未指定。当需要对解码过程进行更多控制时，应使用 CharsetDecoder 类。
  
  参数：
  
  bytes - 要解码为字符的字节
  
  自从：
  
  1.1
- String
  
  public String(StringBuffer buffer)
  
  分配一个新字符串，其中包含当前包含在字符串缓冲区参数中的字符序列。复制字符串缓冲区的内容；字符串缓冲区的后续修改不会影响新创建的字符串。
  
  参数：
  
  buffer - 一个 StringBuffer
- String
  
  public String(StringBuilder builder)
  
  分配一个新字符串，其中包含当前包含在字符串生成器参数中的字符序列。复制字符串生成器的内容；字符串生成器的后续修改不会影响新创建的字符串。
  提供此构造函数是为了简化向 StringBuilder 的迁移。通过 toString 方法从字符串生成器获取字符串可能运行得更快，通常是首选。
  
  参数：
  
  builder - 一个 StringBuilder
  
  自从：
  
  1.5

方法详情

length

public int length()

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

指定者：

length 在接口 CharSequence 中

返回：

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

public boolean isEmpty()

当且仅当 length() 是 0 时返回 true。

指定者：

isEmpty 在接口 CharSequence 中

返回：

true 如果 length() 是 0 ，否则 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 值的索引

返回：

index 处字符的代码点值

抛出：

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 s 为单位）为 endIndex-beginIndex 。文本范围内未配对的代理项各计为一个代码点。

参数：

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

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

返回：

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

抛出：

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

自从：

1.5
offsetByCodePoints

public int offsetByCodePoints(int index, int codePointOffset)

返回此 String 中的索引，该索引从给定的 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 ）。字符被复制到 dst 的子数组中，从索引 dstBegin 开始到索引结束：
```
   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)

已弃用。
此方法不能正确地将字符转换为字节。从 JDK 1.1 开始，首选方法是通过使用 default charset 的 getBytes() 方法。
将此字符串中的字符复制到目标字节数组中。每个字节接收相应字符的低 8 位。每个字符的高八位不被复制，也不以任何方式参与传输。
要复制的第一个字符位于索引 srcBegin ；要复制的最后一个字符位于索引 srcEnd-1 处。要复制的字符总数为 srcEnd-srcBegin 。转换为字节的字符被复制到 dst 的子数组中，从索引 dstBegin 开始到索引结束：
```
   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 - 支持的名称 charset

返回：

结果字节数组

抛出：

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

自从：

1.1
getBytes

public byte[] getBytes(Charset charset)

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

参数：

charset - 用于编码 String 的 Charset

返回：

结果字节数组

自从：

1.6
getBytes

public byte[] getBytes()

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

返回：

结果字节数组

自从：

1.1
equals

public boolean equals(Object anObject)

将此字符串与指定对象进行比较。结果是 true 当且仅当参数不是 null 并且是一个 String 对象，表示与该对象相同的字符序列。
有关更细粒度的字符串比较，请参阅 Collator 。
重写：

equals 在类 Object 中

参数：

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

返回：

true 如果给定的对象代表一个 String 相当于这个字符串，false 否则

参见：
- compareTo(String)
- equalsIgnoreCase(String)
contentEquals

public boolean contentEquals(StringBuffer sb)

将此字符串与指定的 StringBuffer 进行比较。当且仅当此 String 表示与指定的 StringBuffer 相同的字符序列时，结果为 true。此方法在 StringBuffer 上同步。
有关更细粒度的字符串比较，请参阅 Collator 。

参数：

sb - 将此 String 与 StringBuffer 进行比较

返回：

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

自从：

1.4
contentEquals

public boolean contentEquals(CharSequence cs)

将此字符串与指定的 CharSequence 进行比较。当且仅当此 String 表示与指定序列相同的 char 值序列时，结果为 true。请注意，如果 CharSequence 是 StringBuffer，则该方法会对其进行同步。
有关更细粒度的字符串比较，请参阅 Collator 。

参数：

cs - 比较这个 String 的序列

返回：

true 如果此 String 表示与指定序列相同的 char 值序列， false 否则

自从：

1.5
equalsIgnoreCase

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

anotherString - 用于比较此 String 的 String

返回：

true 如果参数不是 null 并且它表示等效的 String 忽略大小写； false否则

参见：
- equals(Object)
- codePoints()
compareTo

public int compareTo(String anotherString)
按字典顺序比较两个字符串。比较基于字符串中每个字符的 Unicode 值。此 String 对象表示的字符序列按字典顺序与参数字符串表示的字符序列进行比较。如果此 String 对象在字典顺序上位于参数字符串之前，则结果为负整数。如果此 String 对象按字典顺序跟随参数字符串，则结果为正整数。如果字符串相等，则结果为零；否则compareTo 恰好在 equals(Object) 方法返回 true 时返回 0。
这是字典序的定义。如果两个字符串不同，那么它们要么在某个索引处具有不同的字符，该索引是两个字符串的有效索引，要么它们的长度不同，要么两者兼而有之。如果它们在一个或多个索引位置有不同的字符，让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)) 消除了大小写差异。
请注意，此方法确实 not 考虑了区域设置，并且会导致某些区域设置的排序不令人满意。 Collator 类提供区域设置敏感的比较。
参数：

str - 要比较的 String。

返回：

负整数、零或正整数，因为指定的字符串大于、等于或小于此字符串，忽略大小写。

自从：

1.2

参见：
- Collator
- codePoints()
regionMatches

public boolean regionMatches(int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
此 String 对象的子字符串与参数 other 的子字符串进行比较。如果这些子字符串表示相同的字符序列，则结果为真。要比较的这个 String 对象的子字符串从索引 toffset 开始，长度为 len。要比较的 other 的子字符串从索引 ooffset 开始，长度为 len 。结果为 false 当且仅当以下至少一项为真：
- toffset 是否定的。
- ooffset 是否定的。
- toffset+len 大于此 String 对象的长度。
- ooffset+len 大于另一个参数的长度。
- 存在某个非负整数k小于 len 这样： this.charAt(toffset + k) != other.charAt(ooffset + k)
请注意，此方法确实not 考虑了locale。 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 为真时忽略大小写。比较序列 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) ) 会产生相等的整数值。
请注意，此方法确实 not 考虑了区域设置，并且当 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 - 从哪里开始查找此字符串。

返回：
true 如果参数表示的字符序列是此对象从索引 toffset 开始的子字符串的前缀； 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字符串的第th个字符，n为字符串长度，^表示求幂。（空字符串的哈希值为零。）
重写：

hashCode 在类 Object 中

返回：

此对象的哈希码值。

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

public int indexOf(int ch)
返回指定字符在此字符串中第一次出现的索引。如果值为 ch 的字符出现在此 String 对象表示的字符序列中，则返回第一个此类出现的索引（以 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)
返回指定字符在此字符串中第一次出现的索引，从指定索引处开始搜索。
如果值为 ch 的字符出现在此 String 对象表示的字符序列中，索引不小于 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 代码单元）中指定。
参数：

ch - 一个字符（Unicode 代码点）。

fromIndex - 开始搜索的索引。

返回：

此对象表示的大于或等于 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 从最后一个字符开始向后搜索。
参数：

ch - 一个字符（Unicode 代码点）。

返回：

此对象表示的字符序列中最后一次出现该字符的索引，如果该字符未出现，则为 -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 代码单元）中指定。
参数：

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。
参数：

str - 要搜索的子字符串。

fromIndex - 开始搜索的索引。

返回：

指定子字符串第一次出现的索引，从指定索引开始，如果没有这样的出现，则为 -1。
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) returns "happy"
 "Harbison".substring(3) returns "bison"
 "emptiness".substring(9) returns "" (an empty string)
 
```
参数：

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

返回：

指定的子字符串。

抛出：

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"
 
```
参数：

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") returns "caress"
 "to".concat("get").concat("her") returns "together"
 
```
参数：

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

返回：

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

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

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

oldChar - 旧角色。

newChar - 新角色。

返回：

通过将每次出现的 oldChar 替换为 newChar 从此字符串派生的字符串。
matches

public boolean matches(String regex)

判断此字符串是否与给定的正则表达式匹配。
调用此表单方法海峡.matches( 正则表达式) 产生与表达式完全相同的结果

Pattern .matches(regex, str)
参数：

regex - 此字符串要匹配的正则表达式

返回：

true 当且仅当此字符串匹配给定的正则表达式

抛出：

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

自从：

1.4

参见：
- Pattern
contains

public boolean contains(CharSequence s)

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

参数：

s - 要搜索的序列

返回：

如果此字符串包含 s 则为真，否则为假

自从：

1.5
replaceFirst

public String replaceFirst(String regex, String replacement)

用给定的替换替换此字符串中与给定的正则表达式匹配的第一个子字符串。
调用此表单方法海峡.replaceFirst( 正则表达式, 回复) 产生与表达式完全相同的结果

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)

用给定的替换替换此字符串中与给定的正则表达式匹配的每个子字符串。
调用此表单方法海峡.replaceAll( 正则表达式, 回复) 产生与表达式完全相同的结果

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 - 要替换的 char 值序列

replacement - char 值的替换顺序

返回：

结果字符串

自从：

1.5

split

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

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

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

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

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

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

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

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

Regex 限制 Result

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

调用此表单方法海峡split( 正则表达式, n) 产生与表达式相同的结果

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

参数：

regex - 定界正则表达式

limit - 结果阈值，如上所述

返回：

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

抛出：

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

自从：

1.4

参见：

split

public String [] split(String regex)

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

此方法的工作方式就好像通过使用给定表达式和零限制参数调用双参数 split 方法一样。因此，结果数组中不包含尾随的空字符串。

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

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

Regex Result

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

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

参数：

regex - 定界正则表达式

返回：

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

抛出：

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

自从：

1.4

参见：

join

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

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

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

返回：

一个新的 String 由 elements 组成，由 delimiter 分隔

抛出：

NullPointerException - 如果 delimiter 或 elements 是 null

自从：

1.8

参见：
- StringJoiner
join

public static String join(CharSequence delimiter, Iterable <? extends CharSequence > elements)
返回一个新的 String 由 CharSequence elements 的副本和指定的 delimiter 的副本组成。
例如，
```
   List<String> strings = List.of("Java", "is", "cool");
   String message = String.join(" ", strings);
   // message returned is: "Java is cool"

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

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

elements - 一个 Iterable 将其 elements 连接在一起。

返回：

由 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 的长度可能不同。

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

显示locale、大写、小写和描述的语言代码的小写映射示例
locale代码	大写字母	小写	Description
tr（土耳其语）	\u0130	\u0069	上面带点的大写字母 I -> 小写字母 i
tr（土耳其语）	\u0049	\u0131	大写字母 I -> 小写字母无点 i
（全部）	炸薯条	炸薯条	小写字符串中的所有字符
（全部）	ΙχΘΥΣ	ιχθυσ	小写字符串中的所有字符

参数：

locale - 使用此locale的大小写转换规则

返回：

String ，转换为小写。

自从：

1.1

参见：

toLowerCase

public String toLowerCase()

使用默认locale的规则将此 String 中的所有字符转换为小写。此方法等效于 toLowerCase(Locale.getDefault()) 。
笔记：此方法对区域设置敏感，如果用于旨在独立解释区域设置的字符串，可能会产生意外结果。示例是编程语言标识符、协议密钥和 HTML 标记。例如，土耳其locale中的 "TITLE".toLowerCase() 返回 "t\u0131tle" ，其中 '\u0131' 是拉丁文小写字母 DOTLESS I 字符。要获得不区分locale的字符串的正确结果，请使用 toLowerCase(Locale.ROOT) 。
返回：

String ，转换为小写。

参见：
- toLowerCase(Locale)

toUpperCase

public String toUpperCase(Locale locale)

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

下表列出了区域设置敏感和 1:M 大小写映射的示例：

区域设置敏感和 1:M 大小写映射的示例。显示区域、小写、大写和描述的语言代码。
locale代码	小写	大写字母	Description
tr（土耳其语）	\u0069	\u0130	小写字母 i -> 大写字母 I 上面有点
tr（土耳其语）	\u0131	\u0049	小写字母无点 i -> 大写字母 I
（全部）	\u00df	\u0053 \u0053	小写字母 sharp s -> 两个字母：SS
（全部）	Fahrvergnügen	法尔维尔根

参数：

locale - 使用此locale的大小写转换规则

返回：

String ，转换为大写。

自从：

1.1

参见：

toUpperCase

public String toUpperCase()

使用默认locale的规则将此 String 中的所有字符转换为大写。此方法等效于 toUpperCase(Locale.getDefault()) 。
笔记：此方法对区域设置敏感，如果用于旨在独立解释区域设置的字符串，可能会产生意外结果。示例是编程语言标识符、协议密钥和 HTML 标记。例如，土耳其locale中的 "title".toUpperCase() 返回 "T\u0130TLE" ，其中 '\u0130' 是拉丁文大写字母 I WITH DOT ABOVE 字符。要获得不区分locale的字符串的正确结果，请使用 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()

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

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

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

API 注意：

这个定义线意味着空字符串有零行，并且在字符串末尾的行终止符后面没有空行。

实现注意事项：

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

返回：

从此字符串中提取的行流

自从：

11
indent

public String indent(int n)

根据 n 的值调整此字符串每行的缩进，并规范化行终止字符。
该字符串在概念上使用 lines() 分成几行。然后按如下所述调整每一行，然后添加换行符 "\n" (U+000A)。然后将生成的行连接起来并返回。

If n > 0 then n spaces (U+0020) is inserted at the beginning of each line.

如果 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>
 
```
首先，提取该字符串的各行。 A线是由零个或多个字符组成的序列，后跟行终止符或字符串结尾。如果字符串至少有一个行终止符，则最后一行由最后一个终止符和字符串末尾之间的字符组成。否则，如果字符串没有终止符，则最后一行是字符串的开头到字符串的结尾，换句话说，就是整个字符串。一行不包括行终止符。
然后，最小缩进（分钟）确定如下：
- 对于每个非空行（由 isBlank() 定义），前导空白字符被计算在内。
- 即使空白的，最后一行的前导空白字符也被计算在内。
这minvalue 是这些计数中最小的。

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

最后，这些行被连接成一个新的字符串，使用 LF 字符 "\n" (U+000A) 来分隔行。
API 注意：

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

实现要求：

此方法将所有空白个字符视为具有相同的宽度。只要每一行的缩进始终由相同的字符序列组成，那么结果就会像上面描述的那样。

返回：

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

自从：

15

参见：

translateEscapes

public String translateEscapes()

返回一个字符串，其值为该字符串，转义序列被翻译成字符串文字。

转义序列翻译如下；

翻译
逃脱	Name	翻译
`\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>`	继续	丢弃

实现注意事项：: 此方法确实not 转换 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()

返回一个 int 流，对该序列的 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是 Locale.getDefault(Locale.Category) 返回的locale，其中指定了 FORMAT 类别。
参数：

format - 一个格式字符串

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

返回：

格式化的字符串

抛出：

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

自从：

1.5

参见：
- Formatter
format

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

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

l - 在格式化期间应用的 locale。如果 l 是 null 则不应用本地化。

format - 一个格式字符串

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

返回：

格式化的字符串

抛出：

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

自从：

1.5

参见：
- Formatter
formatted

public String formatted(Object ... args)

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

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

参数：

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

返回：

格式化的字符串

自从：

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 方法时，如果池中已经包含等于 equals(Object) 方法确定的此 String 对象的字符串，则返回池中的字符串。否则，会将此 String 对象添加到池中并返回对此 String 对象的引用。

由此得出，对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 是 true 时，s.intern() == t.intern() 是 true。

所有文字字符串和字符串值常量表达式都是驻留的。字符串文字在 3.10.5 节中定义Java 语言规范.

返回：

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

public String repeat(int count)

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

参数：

count - 重复次数

返回：

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

抛出：

IllegalArgumentException - 如果 count 为负。

自从：

11
describeConstable

public Optional <String > describeConstable()

返回一个 Optional ，其中包含此实例的标称描述符，即实例本身。

指定者：

describeConstable 在接口 Constable 中

返回：

Optional 描述了 String 实例

自从：

12
resolveConstantDesc

public String resolveConstantDesc(MethodHandles.Lookup lookup)

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

指定者：

resolveConstantDesc 在接口 ConstantDesc 中

参数：

lookup - 忽略

返回：

String 实例

自从：

12

Regex	限制	Result
:	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" }`

类 String

字段摘要

构造方法总结

方法总结

在类 java.lang.Object 中声明的方法

字段详细信息

CASE_INSENSITIVE_ORDER

构造方法详细信息

String

String

String

String

String

String

String

String

String

String

String

String

String

String

String

方法详情

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

strip

stripLeading

stripTrailing

isBlank

lines