模块  java.base
软件包  java.lang

Class String

  • 实现的所有接口
    Serializable ， CharSequence ， Comparable<String> 
    public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence
    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参数传递给null中的构造函数或方法将导致抛出NullPointerException 。

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

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

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

    Implementation Note:
    只要编译器最终符合Java的语言规范 ，字符串连接运算符的实现由Java编译器决定。 例如， javac编译器可实现运营商StringBuffer ， StringBuilder ，或java.lang.invoke.StringConcatFactory取决于JDK版本。 字符串转换的实现通常是通过方法toString ，由Object定义并由Java中的所有类继承。
    从以下版本开始：
    1.0
    另请参见：
    Object.toString() ， StringBuffer ， StringBuilder ， Charset ， Serialized Form
    See The Java™ Language Specification:
    15.18.1字符串连接运算符+

    • 构造方法摘要

      构造方法  
      构造器 描述
      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 。
      String​(byte[] bytes, int offset, int length, Charset charset)
      通过使用指定的charset解码指定的字节子String构造新的String 。
      String​(byte[] bytes, String charsetName)
      构造一个新的String由指定用指定的字节的数组解码charset 。
      String​(byte[] bytes, Charset charset)
      构造一个新的String由指定用指定的字节的数组解码charset 。
      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)
      分配一个新字符串，其中包含当前包含在字符串构建器参数中的字符序列。

    • 方法摘要

      所有方法  静态方法  实例方法 具体的方法  弃用的方法 
      变量和类型 方法 描述
      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) 。
      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)
      使用指定的语言环境，格式字符串和参数返回格式化的字符串。
      byte[] getBytes()
      使用平台的默认字符集将此 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()
      返回此字符串的哈希码。
      int indexOf​(int ch)
      返回指定字符第一次出现的字符串中的索引。
      int indexOf​(int ch, int fromIndex)
      返回指定字符第一次出现的此字符串中的索引，从指定索引处开始搜索。
      int indexOf​(String str)
      返回指定子字符串第一次出现的字符串中的索引。
      int indexOf​(String str, int fromIndex)
      从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
      String intern()
      返回字符串对象的规范表示。
      boolean isBlank()
      如果字符串为空或仅包含 white space代码点，则返回 true ，否则 false 。
      boolean isEmpty()
      返回 true ，当且仅当， length()是 0 。
      static String join​(CharSequence delimiter, CharSequence... elements)
      返回由 CharSequence elements的副本组成的新String，该副本与指定的 delimiter的副本连接在一起。
      static String join​(CharSequence delimiter, Iterable<? extends CharSequence> elements)
      返回由 String的副本组成的新 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)
      判断此字符串是否与给定的 regular expression匹配。
      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)
      将给定替换的给定 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)
      测试从指定索引开始的此字符串的子字符串是否以指定的前缀开头。
      String strip()
      返回一个字符串，其值为此字符串，并删除了所有前导和尾随 white space 。
      String stripLeading()
      返回一个字符串，其值为此字符串，并删除了所有前导 white space 。
      String stripTrailing()
      返回一个字符串，其值为此字符串，并删除所有尾随 white space 。
      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所有字符转换为 Locale 。
      String toString()
      这个对象（已经是一个字符串！）
      String toUpperCase()
      使用默认语言环境的规则将此 String所有字符转换为大写。
      String toUpperCase​(Locale locale)
      使用给定 Locale的规则将此 String所有字符转换为大写。
      String trim()
      返回一个字符串，其值为此字符串，删除了所有前导和尾随空格，其中space被定义为其代码点小于或等于 '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参数的字符串表示形式。

    • 字段详细信息

      • CASE_INSENSITIVE_ORDER

        public static final Comparator<String> CASE_INSENSITIVE_ORDER
        由compareToIgnoreCase订购String对象的比较compareToIgnoreCase 。 该比较器是可序列化的。

        请注意，此比较器不会考虑区域设置，并且会导致某些区域设置的排序不令人满意。 Collator类提供区域设置敏感的比较。

        从以下版本开始：
        1.2
        另请参见：
        Collator

    • 构造方法详细信息

      • String

        public String()
        初始化新创建的String对象，使其表示空字符序列。 请注意，由于字符串是不可变的，因此不必使用此构造函数。

      • String

        public String​(String original)
        初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。 除非需要original的显式副本， original不必使用此构造函数，因为字符串是不可变的。
        参数
        original - A String

      • String

        public String​(char[] value)
        分配新的String ，使其表示当前包含在字符数组参数中的字符序列。 复制字符数组的内容; 后续修改字符数组不会影响新创建的字符串。
        参数
        value - 字符串的初始值

      • String

        public String​(char[] value,
              int offset,
              int count)
        分配一个新的String ，其中包含字符数组参数的子数组中的字符。 offset参数是子count的第一个字符的索引， count参数指定子count的长度。 复制子阵列的内容; 后续修改字符数组不会影响新创建的字符串。
        参数
        value - 作为字符源的数组
        offset - 初始偏移量
        count - 长度
        异常
        IndexOutOfBoundsException - 如果 offset为负数，则 count为负数，或 offset为大于 value.length - count

      • String

        public String​(int[] codePoints,
              int offset,
              int count)
        分配一个新的String ，其中包含Unicode code point数组参数的子数组中的字符。 offset参数是子count的第一个代码点的索引， count参数指定子count的长度。 子阵列的内容转换为char s; 后续修改int数组不会影响新创建的字符串。
        参数
        codePoints - 作为Unicode代码点源的数组
        offset - 初始偏移量
        count - 长度
        异常
        IllegalArgumentException - 如果在 codePoints找到任何无效的Unicode代码点
        IndexOutOfBoundsException - 如果 offset为负数，则 count为负数，或 offset为大于 codePoints.length - count
        从以下版本开始：
        1.5

      • String

        public String​(byte[] bytes,
              int offset,
              int length,
              String charsetName)
       throws UnsupportedEncodingException
        通过使用指定的字符集解码指定的字节子String构造新的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)
        构造一个新的String通过使用指定的指定字节子阵列解码charset 。 新String的长度是字符集的函数，因此可能不等于子String的长度。

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

        参数
        bytes - 要解码为字符的字节
        offset - 要解码的第一个字节的索引
        length - 要解码的字节数
        charset -该charset被用来解码bytes
        异常
        IndexOutOfBoundsException - 如果 offset为负数， length为负数，或 offset为大于 bytes.length - length
        从以下版本开始：
        1.6

      • String

        public String​(byte[] bytes,
              String charsetName)
       throws UnsupportedEncodingException
        构造一个新的String由指定用指定的字节的数组解码charset 。 新String的长度是字符集的函数，因此可能不等于字节数组的长度。

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

        参数
        bytes - 要解码为字符的字节
        charsetName - 支持的charset的名称
        异常
        UnsupportedEncodingException - 如果不支持指定的字符集
        从以下版本开始：
        1.1

      • String

        public String​(byte[] bytes,
              Charset charset)
        构造一个新的String由指定用指定的字节的数组解码charset 。 新String的长度是字符集的函数，因此可能不等于字节数组的长度。

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

        参数
        bytes - 要解码为字符的字节
        charset -该charset被用来解码bytes
        从以下版本开始：
        1.6

      • String

        public String​(byte[] bytes,
              int offset,
              int length)
        通过使用平台的默认字符集解码指定的字节子阵列来构造新的String 。 新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 - A StringBuffer

      • String

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

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

        参数
        builder - A StringBuilder
        从以下版本开始：
        1.5

    • 方法详细信息

      • length

        public int length()
        返回此字符串的长度。 长度等于字符串中的Unicode code units的数量。
        Specified by:
        length在界面 CharSequence
        结果
        此对象表示的字符序列的长度。

      • isEmpty

        public boolean isEmpty()
        返回 true ，当且仅当， length()是 0 。
        结果
        true如果 length()是 0 ，否则 false
        从以下版本开始：
        1.6

      • charAt

        public char charAt​(int index)
        返回指定索引处的char值。 指数范围为0至length() - 1 。 序列的第一个char值位于索引0 ，下一个位于索引1 ，依此类推，就像数组索引一样。

        如果char由索引指定的值是surrogate ，则返回所述替代值。

        Specified by:
        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 。

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

        参数
        index - 应返回的代码点后面的索引
        结果
        给定索引之前的Unicode代码点值。
        异常
        IndexOutOfBoundsException - 如果 index参数小于1或大于此字符串的长度。
        从以下版本开始：
        1.5

      • codePointCount

        public int codePointCount​(int beginIndex,
                          int endIndex)
        返回此String的指定文本范围内的Unicode代码点数。 文本范围从指定的beginIndex开始，并延伸至char ，索引号为endIndex - 1 。 因此，文本范围的长度（在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的子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)
        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 platform's default charset.
        将此字符串中的字符复制到目标字节数组中。 每个字节接收相应字符的8个低位。 每个字符的八个高位不会被复制，也不会以任何方式参与传输。

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

             dstBegin + (srcEnd-srcBegin) - 1
        参数
        srcBegin - 要复制的字符串中第一个字符的索引
        srcEnd - 要复制的字符串中最后一个字符后的索引
        dst - 目标阵列
        dstBegin - 目标阵列中的起始偏移量
        异常
        IndexOutOfBoundsException - 如果满足以下任何条件：
        • srcBegin是否定的
        • srcBegin大于srcEnd
        • srcEnd大于此String的长度
        • dstBegin是否定的
        • dstBegin+(srcEnd-srcBegin)大于dst.length

      • getBytes

        public byte[] getBytes​(String charsetName)
                throws UnsupportedEncodingException
        使用指定的字符集将此String编码为字节序列，将结果存储到新的字节数组中。

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

        参数
        charsetName - 支持的charset的名称
        结果
        结果字节数组
        异常
        UnsupportedEncodingException - 如果不支持指定的charset
        从以下版本开始：
        1.1

      • getBytes

        public byte[] getBytes​(Charset charset)
        使用给定的charset将此String编码为字节序列，将结果存储到新的字节数组中。

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

        参数
        charset -该Charset被用于编码String
        结果
        结果字节数组
        从以下版本开始：
        1.6

      • getBytes

        public byte[] getBytes()
        使用平台的默认字符集将此String编码为字节序列，将结果存储到新的字节数组中。

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

        结果
        结果字节数组
        从以下版本开始：
        1.1

      • equals

        public boolean equals​(Object anObject)
        将此字符串与指定的对象进行比较。 当且仅当参数不是null且是String对象表示与此对象相同的字符序列时，结果为true 。

        有关更精细的字符串比较，请参阅Collator 。

        重写：
        equals在类 Object
        参数
        anObject - 对比对比 String的对象
        结果
        true如果给定的对象表示 String相当于这个字符串， false否则
        另请参见：
        compareTo(String) ， equalsIgnoreCase(String)

      • contentEquals

        public boolean contentEquals​(StringBuffer sb)
        将此字符串与指定的StringBuffer 。 其结果是true ，如果，如果这仅String表示字符作为指定的相同序列StringBuffer 。 此方法在StringBuffer上同步。

        有关更精细的字符串比较，请参阅Collator 。

        参数
        sb - 用 StringBuffer来比较这 String
        结果
        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比较，忽略了大小写。 如果两个字符串具有相同的长度并且两个字符串中的相应字符等于忽略大小写，则认为它们是相等的忽略大小写。

        如果至少满足下列条件之一，则两个字符c1和c2被视为相同的忽略大小写：

        • 两个字符相同（由==运营商比较）
        • 在每个字符上调用Character.toLowerCase(Character.toUpperCase(char))会产生相同的结果

        请注意，此方法不场所考虑，并会导致特定的语言环境不令人满意的结果。 Collator类提供区域设置敏感的比较。

        参数
        anotherString - 用 String来比较这 String对比
        结果
        true如果参数不是null并且它代表等效的String忽略大小写; 否则为false
        另请参见：
        equals(Object)

      • compareTo

        public int compareTo​(String anotherString)
        按字典顺序比较两个字符串。 比较基于字符串中每个字符的Unicode值。 此String对象表示的字符序列按字典顺序与参数字符串表示的字符序列进行比较。 如果此String对象按字典顺序排在参数字符串之前，则结果为负整数。 如果此String对象按字典顺序跟随参数字符串，则结果为正整数。 如果字符串相等，结果为零; compareTo在equals(Object)方法返回0完全返回true 。

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

         this.charAt(k)-anotherString.charAt(k)
        如果没有它们不同的索引位置，那么较短的字符串按字典顺序排在较长的字符串之前。 在这种情况下， compareTo返回字符串长度的差异 - 即值： 
         this.length()-anotherString.length()

        有关更精细的字符串比较，请参阅Collator 。

        Specified by:
        compareTo在 Comparable<String>
        参数
        anotherString - 待比较的 String 。
        结果
        如果参数字符串等于此字符串，则值0 ; 如果此字符串按字典顺序小于字符串参数，则小于0 ; 如果此字符串按字典顺序大于字符串参数，则值大于0 。

      • compareToIgnoreCase

        public int compareToIgnoreCase​(String str)
        按字典顺序比较两个字符串，忽略大小写差异。 此方法返回一个整数，其符号是调用compareTo的整数，其中字符串的规范化版本通过在每个字符上调用Character.toLowerCase(Character.toUpperCase(character))消除了大小写差异。

        请注意，此方法不场所考虑，并会导致特定的语言环境不满意的排序。 Collator类提供区域设置敏感的比较。

        参数
        str - 待比较的 String 。
        结果
        一个负整数，零或正整数，因为指定的String大于，等于或小于此String，忽略了大小写。
        从以下版本开始：
        1.2
        另请参见：
        Collator

      • regionMatches

        public boolean regionMatches​(int toffset,
                             String other,
                             int ooffset,
                             int len)
        测试两个字符串区域是否相等。

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

        • toffset是否定的。
        • ooffset是否定的。
        • toffset+len大于此String对象的长度。
        • ooffset+len大于另一个参数的长度。
        • 有一些非负整数k小于len ，使得： this.charAt(toffset + k ) != other.charAt(ooffset + k )

        请注意，此方法不场所考虑。 Collator类提供区域设置敏感的比较。

        参数
        toffset - 此字符串 toffset区域的起始偏移量。
        other - 字符串参数。
        ooffset - 字符串参数 ooffset区域的起始偏移量。
        len - 要比较的字符数。
        结果
        true如果此字符串的指定子区域与字符串参数的指定子区域完全匹配; 否则为false 。

      • regionMatches

        public boolean regionMatches​(boolean ignoreCase,
                             int toffset,
                             String other,
                             int ooffset,
                             int len)
        测试两个字符串区域是否相等。

        将此String对象的子字符串与参数other的子字符串进行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(Character.toUpperCase(this.charAt(toffset+k))) !=
     Character.toLowerCase(Character.toUpperCase(other.charAt(ooffset+k)))

        请注意，此方法不场所考虑，并会导致特定的语言环境不理想结果时ignoreCase为true 。 Collator类提供区域设置敏感的比较。

        参数
        ignoreCase - 如果是 true ，请在比较字符时忽略大小写。
        toffset - 此字符串 toffset区域的起始偏移量。
        other - 字符串参数。
        ooffset - 字符串参数 ooffset区域的起始偏移量。
        len - 要比较的字符数。
        结果
        true如果此字符串的指定子区域与字符串参数的指定子区域匹配; 否则为false 。 匹配是精确匹配还是不区分大小写取决于ignoreCase参数。

      • 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 。 还需要注意的是true如果参数为空字符串或等于该将被返回String如由测定对象equals(Object)方法。
        从以下版本开始：
        1.0

      • endsWith

        public boolean endsWith​(String suffix)
        测试此字符串是否以指定的后缀结尾。
        参数
        suffix - 后缀。
        结果
        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]是字符串的第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)
        返回指定字符第一次出现的此字符串中的索引，从指定索引处开始搜索。

        如果在索引不小于fromIndex ，此String对象表示的字符序列中出现值为ch的字符，则返回第一个此类出现的索引。 对于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)
        返回指定字符最后一次出现的字符串中的索引。 对于范围为0到0xFFFF（包括）的ch值， ch的索引（以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)
        返回指定字符最后一次出现的字符串中的索引，从指定的索引开始向后搜索。 对于范围为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返回。
        参数
        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)
        Specified by:
        subSequence在界面 CharSequence
        API Note:
        定义此方法，以便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每个匹配项替换为 oldChar ， newChar字符串派生的字符串。

      • matches

        public boolean matches​(String regex)
        判断此字符串是否与给定的regular expression匹配。

        调用str .matches( regex )形式的此方法会产生与表达式完全相同的结果

        Pattern. matches(regex, str)
        参数
        regex - 要与此字符串匹配的正则表达式
        结果
        true if且仅当此字符串与给定的正则表达式匹配时
        异常
        PatternSyntaxException - 如果正则表达式的语法无效
        从以下版本开始：
        1.4
        另请参见：
        Pattern

      • contains

        public boolean contains​(CharSequence s)
        当且仅当此字符串包含指定的char值序列时，才返回true。
        参数
        s - 要搜索的序列
        结果
        如果此字符串包含 s ，则返回true，否则 s false
        从以下版本开始：
        1.5

      • replaceFirst

        public String replaceFirst​(String regex,
                           String replacement)
        将给定替换的给定regular expression匹配的此字符串的第一个子字符串替换。

        调用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)
        将给定替换的给定regular expression匹配的此字符串的每个子字符串替换。

        调用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 - 要替换的char值序列
        replacement - char值的替换序列
        结果
        结果字符串
        从以下版本开始：
        1.5

      • split

        public String[] split​(String regex,
                      int limit)
        将此字符串拆分为给定regular expression的匹配项 。

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

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

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

        • 如果限制为正，则模式将应用最多限制 - 1次，数组的长度不会超过限制 ，并且数组的最后一个条目将包含超出最后一个匹配分隔符的所有输入。

        • 如果限制为零，则模式将尽可能多地应用，数组可以具有任何长度，并且将丢弃尾随空字符串。

        • 如果限制为负，则模式将尽可能多地应用，并且数组可以具有任何长度。

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

        Split example showing regex, limit, and result
        Regex Limit 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" }

        调用str形式的这个方法。 split( regex , n )产生与表达式相同的结果

        Pattern.compile(regex).split(str, n)
        参数
        regex - 分隔正则表达式
        limit - 结果阈值，如上所述
        结果
        通过在给定正则表达式的匹配项周围拆分此字符串计算的字符串数组
        异常
        PatternSyntaxException - 如果正则表达式的语法无效
        从以下版本开始：
        1.4
        另请参见：
        Pattern

      • split

        public String[] split​(String regex)
        将此字符串拆分为给定regular expression的匹配项 。

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

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

        Split examples showing regex and result
        Regex Result
        : { "boo", "and", "foo" }
        o { "b", "", ":and:f" }
        参数
        regex - 分隔正则表达式
        结果
        通过在给定正则表达式的匹配项周围拆分此字符串计算的字符串数组
        异常
        PatternSyntaxException - 如果正则表达式的语法无效
        从以下版本开始：
        1.4
        另请参见：
        Pattern

      • join

        public static String join​(CharSequence delimiter,
                          CharSequence... elements)
        返回由CharSequence elements的副本组成的新String，该副本与指定的delimiter的副本连接在一起。
        For example, 
        
     String message = String.join("-", "Java", "is", "cool");
     // message returned is: "Java-is-cool"
        请注意，如果元素为null，则添加"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的副本组成的新String ，其中CharSequence elements指定的delimiter的副本。
        For example, 
        
     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 -用于向每一个的分开的字符序列 elements在所得 String
        elements - Iterable将其 elements连接在一起。
        结果
        由 elements参数组成的新 String
        异常
        NullPointerException - 如果 delimiter或 elements是 null
        从以下版本开始：
        1.8
        另请参见：
        join(CharSequence,CharSequence...) ， StringJoiner

      • toLowerCase

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

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

        Lowercase mapping examples showing language code of locale, upper case, lower case, and description 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
        参数
        locale - 使用此语言环境的大小写转换规则
        结果
        String ，转换为小写。
        从以下版本开始：
        1.1
        另请参见：
        toLowerCase() ， toUpperCase() ， toUpperCase(Locale)

      • toLowerCase

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

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

        结果
        String ，转换为小写。
        另请参见：
        toLowerCase(Locale)

      • toUpperCase

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

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

        Examples of locale-sensitive and 1:M case mappings. Shows Language code of locale, lower case, upper case, and description. 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
        参数
        locale - 使用此区域设置的大小写转换规则
        结果
        String ，转换为大写。
        从以下版本开始：
        1.1
        另请参见：
        toUpperCase() ， toLowerCase() ， toLowerCase(Locale)

      • toUpperCase

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

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

        结果
        String ，转换为大写。
        另请参见：
        toUpperCase(Locale)

      • trim

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

        如果此String对象表示一个空字符序列，或由该代表字符序列的第一个和最后一个字符String对象都具有不是空间（如上所定义）码，然后该基准String对象被返回。

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

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

        此方法可用于从字符串的开头和结尾修剪空间（如上所述）。

        结果
        一个字符串，其值为此字符串，删除了所有前导和尾随空格，如果没有前导或尾随空格，则为此字符串。

      • strip

        public String strip()
        返回一个字符串，其值为此字符串，并删除了所有前导和尾随white space 。

        如果此String对象表示空字符串，或者此字符串中的所有代码点均为white space ，则返回空字符串。

        否则，返回此字符串的子字符串，该字符串以第一个不是white space的代码点开头，包括最后一个不是white space的代码点。

        该方法可用于从字符串的开头和结尾剥离white space 。

        结果
        一个字符串，其值为此字符串，删除了所有前导和尾随空格
        从以下版本开始：
        11
        另请参见：
        Character.isWhitespace(int)

      • stripLeading

        public String stripLeading()
        返回一个字符串，其值为此字符串，并删除了所有前导white space 。

        如果此String对象表示空字符串，或者此字符串中的所有代码点均为white space ，则返回空字符串。

        否则，返回此字符串的子字符串，该字符串以第一个不是white space的代码点开头，并且包括该字符串的最后一个代码点。

        此方法可用于从字符串的开头修剪white space 。

        结果
        一个字符串，其值为此字符串，删除了所有前导空格
        从以下版本开始：
        11
        另请参见：
        Character.isWhitespace(int)

      • stripTrailing

        public String stripTrailing()
        返回一个字符串，其值为此字符串，并删除所有尾随white space 。

        如果此String对象表示空字符串，或者此字符串中的所有字符均为white space ，则返回空字符串。

        否则，返回此字符串的子字符串，以该字符串的第一个代码点开头，包括最后一个不是white space的代码点。

        此方法可用于从字符串末尾修剪white space 。

        结果
        一个字符串，其值为此字符串，并删除所有尾随空格
        从以下版本开始：
        11
        另请参见：
        Character.isWhitespace(int)

      • isBlank

        public boolean isBlank()
        如果字符串为空或仅包含 white space个代码点，则返回 true ，否则 false 。
        结果
        true如果字符串为空或仅包含 white space代码点，否则为 false
        从以下版本开始：
        11
        另请参见：
        Character.isWhitespace(int)

      • lines

        public Stream<String> lines()
        返回从此字符串中提取的行的流，由行终止符分隔。

        行结束符是以下中的一个：换行符"\n" （U + 000A），回车字符"\r" （U + 000D），或回车换行符紧跟"\r\n" （U + 000D U + 000A） 。

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

        此方法返回的流包含此字符串中出现的行的行。

        API Note:
        这个 行的定义意味着一个空字符串有零行，并且字符串末尾的行终止符后面没有空行。
        Implementation Note:
        通过懒惰地提供元素并更快地搜索新的行终止符，此方法提供了比split（“\ R”）更好的性能。
        结果
        从此字符串中提取的行流
        从以下版本开始：
        11

      • toString

        public String toString()
        这个对象（已经是一个字符串！）本身就返回了。
        Specified by:
        toString在界面 CharSequence
        重写：
        toString在类 Object
        结果
        字符串本身。

      • chars

        public IntStream chars()
        返回int的流，对此序列中的char值进行零扩展。 映射到surrogate code point的任何字符都是未解释的。
        Specified by:
        chars在界面 CharSequence
        结果
        来自此序列的char值的IntStream
        从以下版本开始：
        9

      • codePoints

        public IntStream codePoints()
        返回此序列中的代码点值流。 序列中遇到的任何代理对被组合，就像Character.toCodePoint一样 ，结果传递给流。 任何其他代码单元（包括普通BMP字符，未配对代理和未定义代码单元）都将零扩展为int值，然后传递给流。
        Specified by:
        codePoints在界面 CharSequence
        结果
        Unicode代码的IntStream指向此序列
        从以下版本开始：
        9

      • toCharArray

        public char[] toCharArray()
        将此字符串转换为新的字符数组。
        结果
        新分配的字符数组，其长度为此字符串的长度，其内容初始化为包含此字符串表示的字符序列。

      • format

        public static String format​(String format,
                            Object... args)
        使用指定的格式字符串和参数返回格式化字符串。

        始终使用的语言环境是由Locale.getDefault(Locale.Category)返回的语言环境，其中指定了FORMAT类别。

        参数
        format - A format string
        args - 格式字符串中格式说明符引用的参数。 如果参数多于格式说明符，则忽略额外参数。 参数的数量是可变的，可以为零。 参数的最大数量受The Java™ Virtual Machine Specification定义的Java数组的最大维数限制。 null参数的行为取决于conversion 。
        结果
        格式化的字符串
        异常
        IllegalFormatException - 如果格式字符串包含非法语法，格式说明符与给定参数不兼容，给定格式字符串的参数不足或其他非法条件。 有关所有可能的格式错误的说明，请参阅formatter类规范的Details部分。
        从以下版本开始：
        1.5
        另请参见：
        Formatter

      • format

        public static String format​(Locale l,
                            String format,
                            Object... args)
        使用指定的语言环境，格式字符串和参数返回格式化的字符串。
        参数
        l - 格式化时应用的locale 。 如果l是null则不应用本地化。
        format - A format string
        args - 格式字符串中格式说明符引用的参数。 如果参数多于格式说明符，则忽略额外参数。 参数的数量是可变的，可以为零。 参数的最大数量受The Java™ Virtual Machine Specification定义的Java数组的最大维数限制。 null参数上的行为取决于conversion 。
        结果
        格式化的字符串
        异常
        IllegalFormatException - 如果格式字符串包含非法语法，格式说明符与给定参数不兼容，给定格式字符串的参数不足或其他非法条件。 有关所有可能的格式错误的说明，请参阅formatter类规范的Details部分
        从以下版本开始：
        1.5
        另请参见：
        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 - 字符数组。
        结果
        a String ，包含字符数组的字符。

      • valueOf

        public static String valueOf​(char[] data,
                             int offset,
                             int count)
        返回char数组参数的特定子数组的字符串表示形式。

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

        参数
        data - 字符数组。
        offset - 子阵列的初始偏移量。
        count - 子阵列的长度。
        结果
        a 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 - 子阵列的长度。
        结果
        a 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 - a boolean 。
        结果
        如果参数为true ，则返回等于"true"的字符串; 否则，返回等于"false"的字符串。

      • valueOf

        public static String valueOf​(char c)
        返回 char参数的字符串表示形式。
        参数
        c - a char 。
        结果
        一个长度为 1的字符串， 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 - a long 。
        结果
        long参数的字符串表示形式。
        另请参见：
        Long.toString(long)

      • valueOf

        public static String valueOf​(float f)
        返回float参数的字符串表示形式。

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

        参数
        f - a float 。
        结果
        float参数的字符串表示形式。
        另请参见：
        Float.toString(float)

      • valueOf

        public static String valueOf​(double d)
        返回double参数的字符串表示形式。

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

        参数
        d - a double 。
        结果
        double参数的字符串表示形式。
        另请参见：
        Double.toString(double)

      • intern

        public String intern()
        返回字符串对象的规范表示。

        最初为空的字符串池由类String私有维护。

        调用实习方法时，如果池已包含等于String方法确定的String对象的字符串，则返回池中的字符串。 否则，将此String对象添加到池中，并返回对此String对象的引用。

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

        所有文字字符串和字符串值常量表达式都是实体。 字符串文字在The Java™ Language Specification的 3.10.5节中定义。

        结果
        与此字符串具有相同内容的字符串，但保证来自唯一字符串池。
        See The Java™ Language Specification:
        3.10.5字符串文字

      • repeat

        public String repeat​(int count)
        返回一个字符串，其值为此字符串的串联重复count次。

        如果此字符串为空或count为零，则返回空字符串。

        参数
        count - 重复次数
        结果
        由此字符串组成的字符串重复 count次，如果此字符串为空或count为零，则为空字符串
        异常
        IllegalArgumentException - 如果 count为负数。
        从以下版本开始：
        11