Module  java.base
软件包  java.lang

Class String

  • All Implemented Interfaces:
    SerializableCharSequenceComparable<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

    A String表示UTF-16格式的字符串,其中补充字符代理对表示(有关详细信息,请参阅Character课程中的Character部分)。 索引值是指char代码单元,所以补充字符在String使用两个位置。

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

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

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

      构造方法  
      Constructor 描述
      String​()
      初始化新创建的 String对象,以使其表示空字符序列。
      String​(byte[] bytes)
      通过使用平台的默认字符集解码指定的字节数组来构造新的 String
      String​(byte[] ascii, int hibyte)
      已过时。
      此方法无法将字节正确转换为字符。 从JDK 1.1开始,首选的方法是通过使用Charset ,字符集名称的String构造函数,或者使用平台的默认字符集。
      String​(byte[] bytes, int offset, int length)
      通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String
      String​(byte[] ascii, int hibyte, int offset, int count)
      已过时。
      此方法无法将字节正确转换为字符。 从JDK 1.1开始,首选的方法是通过String构造函数获取Charset ,字符集名称,或者使用平台的默认字符集。
      String​(byte[] bytes, int offset, int length, String charsetName)
      通过使用指定的字符集解码指定的字节 String构造新的 String
      String​(byte[] bytes, int offset, int length, Charset charset)
      构造一个新的String通过使用指定的指定字节子阵列解码charset
      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)
      分配一个新的字符串,其中包含当前包含在字符串构建器参数中的字符序列。
    • 方法摘要

      所有方法  静态方法  接口方法  具体的方法  弃用的方法 
      Modifier and Type 方法 描述
      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)
      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)
      已过时。
      此方法无法将字符正确转换为字节。 从JDK 1.1开始,首选的方法是通过getBytes()方法,该方法使用平台的默认字符集。
      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 isEmpty​()
      返回 true如果,且仅当 length()0
      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​()
      返回此字符串的长度。
      boolean matches​(String regex)
      告诉这个字符串是否匹配给定的 regular expression
      int offsetByCodePoints​(int index, int codePointOffset)
      返回这个 String中的索引,它与给定的 indexcodePointOffset代码点偏移。
      boolean regionMatches​(boolean ignoreCase, int toffset, String other, int ooffset, int len)
      测试两个字符串区域是否相等。
      boolean regionMatches​(int toffset, String other, int ooffset, int len)
      测试两个字符串区域是否相等。
      String replace​(char oldChar, char newChar)
      返回从替换所有出现的导致一个字符串 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)
      测试在指定索引处开始的此字符串的子字符串是否以指定的前缀开头。
      CharSequence subSequence​(int beginIndex, int endIndex)
      返回一个字符序列,该序列是该序列的子序列。
      String substring​(int beginIndex)
      返回一个字符串,该字符串是此字符串的子字符串。
      String substring​(int beginIndex, int endIndex)
      返回一个字符串,该字符串是此字符串的子字符串。
      char[] toCharArray​()
      将此字符串转换为新的字符数组。
      String toLowerCase​()
      使用默认语言环境的规则将此 String所有字符转换为小写。
      String toLowerCase​(Locale locale)
      将此 String所有字符转换为小写,使用给定的 Locale的规则。
      String toString​()
      这个对象(已经是一个字符串!)
      String toUpperCase​()
      将此 String所有字符转换为大写,使用默认语言环境的规则。
      String toUpperCase​(Locale locale)
      将此 String所有字符转换为大写,使用给定的 Locale的规则。
      String trim​()
      返回一个字符串,其值为此字符串,并删除任何前导和尾随空格。
      static String valueOf​(boolean b)
      返回 boolean参数的字符串表示形式。
      static String valueOf​(char c)
      返回 char参数的字符串表示形式。
      static String valueOf​(char[] data)
      返回 char数组参数的字符串表示形式。
      static String valueOf​(char[] data, int offset, int count)
      返回 char数组参数的特定子阵列的字符串表示形式。
      static String valueOf​(double d)
      返回 double参数的字符串表示形式。
      static String valueOf​(float f)
      返回 float参数的字符串表示形式。
      static String valueOf​(int i)
      返回 int参数的字符串表示形式。
      static String valueOf​(long l)
      返回 long参数的字符串表示形式。
      static String valueOf​(Object obj)
      返回 Object参数的字符串表示形式。
    • 字段详细信息

      • CASE_INSENSITIVE_ORDER

        public static final Comparator<String> CASE_INSENSITIVE_ORDER
        该订单比较String对象由compareToIgnoreCase 该比较器可串行化。

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

        从以下版本开始:
        1.2
        另请参见:
        Collator
    • 构造方法详细信息

      • String

        public String​()
        初始化新创建的String对象,使其表示空字符序列。 请注意,使用此构造函数是不必要的,因为Strings是不可变的。
      • String

        public String​(String original)
        初始化新创建的String对象,使其表示与参数相同的字符序列; 换句话说,新创建的字符串是参数字符串的副本。 除非需要显示original副本, original使用此构造函数是不必要的,因为Strings是不可变的。
        参数
        original - A 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 code point数组参数的子阵列中的字符 offset参数是子阵列的第一个代码点的索引,而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的长度。

        此方法总是用此字符集的默认替换字符串替换格式错误的输入和不可映射字符序列。 当需要更多的解码过程控制时,应使用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的长度是字符集的函数,因此可能不等于字节数组的长度。

        此方法总是用此字符集的默认替换字符串替换格式错误的输入和不可映射字符序列。 当需要更多的解码过程控制时,应使用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值。 指数范围从0length() - 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码单位),范围从0length() - 1

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

        参数
        index - 指数为 char
        结果
        字符的代码点值在 index
        异常
        IndexOutOfBoundsException - 如果 index参数为负数或不小于此字符串的长度。
        从以下版本开始:
        1.5
      • codePointBefore

        public int codePointBefore​(int index)
        返回指定索引之前的字符(Unicode代码点)。 该索引是指char值(Unicode代码单位),范围从1length

        如果char(index - 1)(index - 2)(index - 2)char值为(index - 2) ,则返回替代对的(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内的索引,该索引与给定的indexcodePointOffset代码点偏移。 indexcodePointOffset给出的文本范围内的非index codePointOffset作为一个代码点。
        参数
        index - 要偏移的索引
        codePointOffset - 代码点的偏移量
        结果
        该指数在此 String
        异常
        IndexOutOfBoundsException - 如果 index为负或大于该 String的长度,或者如果 codePointOffset为正,并且以 index开头的子串 indexcodePointOffset ,或者如果 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开始,首选的方法是通过使用平台默认字符集的getBytes()方法。
        将此字符串中的字符复制到目标字节数组中。 每个字节接收相应字符的8个低位。 每个字符的八个高位不被复制,也不以任何方式参与转移。

        要复制的第一个字符是索引srcBegin ; 要复制的最后一个字符是索引srcEnd-1 要复制的字符总数为srcEnd-srcBegin 转换为字节的字符将被复制到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 - 如果不支持命名的字符集
        从以下版本开始:
        1.1
      • getBytes

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

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

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

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

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

        结果
        结果字节数组
        从以下版本开始:
        1.1
      • equals

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

        有关更细粒度的字符串比较,请参阅Collator

        重写:
        equalsObject
        参数
        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代表字符的相同序列与指定 StringBufferfalse否则
        从以下版本开始:
        1.4
      • contentEquals

        public boolean contentEquals​(CharSequence cs)
        将此字符串与指定的CharSequence 结果是true当且仅当该String表示与指定序列相同的字符值序列时。 注意,如果CharSequence是一个StringBuffer那么该方法就可以同步它。

        有关更细粒度的字符串比较,请参阅Collator

        参数
        cs - 比较这个 String的序列
        结果
        true如果这个 String表示与指定序列相同的char值序列, false否则
        从以下版本开始:
        1.5
      • equalsIgnoreCase

        public boolean equalsIgnoreCase​(String anotherString)
        将此String比较为另一个String ,忽略案例注意事项。 如果两个字符串的长度相同,并且两个字符串中的相应字符等于忽略大小写,则两个字符串被认为是相等的。

        如果以下至少一个为真,则两个字符c1c2被认为是相同的忽略情况:

        • 两个字符相同(与==操作符相比)
        • 在每个字符上调用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在参数字符串之前。 结果是一个正整数,如果这个String对象按字典顺序跟随参数字符串。 如果字符串相等,结果为零; compareTo返回0equals(Object)方法将返回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对象的子字符串与其他参数的子字符串进行比较。 如果这些子串表示相同的字符序列,结果是真的。 要比较的String对象的子串从索引toffset开始,长度为len 其他要比较的子ooffset始于索引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的子other始于索引ooffset ,长度为len 结果是false当且仅当以下至少有一个是真的:

        • toffset是否定的。
        • ooffset是否定的。
        • toffset+len大于此String对象的长度。
        • ooffset+len大于其他参数的长度。
        • ignoreCasefalse ,有一些非负整数k小于len ,使得:
           this.charAt(toffset+k) != other.charAt(ooffset+k)
           
        • ignoreCasetrue并且有一些非负整数k小于len ,使得:
           Character.toLowerCase(Character.toUpperCase(this.charAt(toffset+k))) !=
               Character.toLowerCase(Character.toUpperCase(other.charAt(ooffset+k)))
           

        请注意,此方法场所考虑,并会导致特定的语言环境不理想结果时ignoreCasetrue 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否则。 结果是false如果toffset为负或大于此String对象的长度; 否则结果与表达式的结果相同
          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是字符串的长度, ^表示取幂。 (空字符串的哈希值为零)
        重写:
        hashCodeObject
        结果
        该对象的哈希码值。
        另请参见:
        Object.equals(java.lang.Object)System.identityHashCode(java.lang.Object)
      • indexOf

        public int indexOf​(int ch)
        返回指定字符第一次出现的字符串内的索引。 如果由String对象表示的字符序列中出现值为ch的字符,则返回首次发生的索引(以Unicode码为单位)。 对于从0到0xFFFF(含)范围内的ch值,这是最小值k ,使得:
         this.charAt(k) == ch
         
        是真的。 对于ch其他值,它是最小值k ,使得:
         this.codePointAt(k) == ch
         
        是真的。 在这两种情况下,如果此字符串中没有这样的字符,则返回-1
        参数
        ch - 一个字符(Unicode代码点)。
        结果
        由该对象表示的字符序列中第一次出现字符的索引,如果字符不发生, -1
      • indexOf

        public int indexOf​(int ch,
                           int fromIndex)
        返回指定字符第一次出现的字符串内的索引,以指定的索引开始搜索。

        如果在该String对象所表示的字符序列中的值为ch的字符发生在不小于fromIndex的索引上,则返回首次发生的索引。 对于从0到0xFFFF(含)范围内的ch值,这是最小值k ,使得:

         (this.charAt(k) == ch) && (k >= fromIndex)
         
        是真的。 对于ch其他值,它是最小值k ,使得:
         (this.codePointAt(k) == ch) && (k >= fromIndex)
         
        是真的。 在这两种情况下,如果这个字符串在位置fromIndex或之后没有发生这样的字符,则返回-1

        fromIndex的价值没有限制。 如果它是否定的,它具有与零一样的效果:可以搜索整个字符串。 如果它大于此字符串的长度,它具有与该字符串的长度相等的效果:返回-1

        所有索引均以char值(Unicode代码单位)指定。

        参数
        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:-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 - 如果 beginIndexendIndex为负数,如果 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 - 新角色。
        结果
        通过替换的每次出现从这个串衍生出的字符串 oldCharnewChar
      • matches

        public boolean matches​(String regex)
        告诉这个字符串是否匹配给定的regular expression

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

        Pattern. matches(regex, str)
        参数
        regex - 要匹配此字符串的正则表达式
        结果
        true如果并且只有这个字符串与给定的正则表达式匹配
        异常
        PatternSyntaxException - 如果正则表达式的语法无效
        从以下版本开始:
        1.4
        另请参见:
        Pattern
      • contains

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

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

        这种方式的调用str .replaceFirst( 正则表达式 , 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( 正则表达式 , 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”中用“b”替换“aa”将导致“ba”而不是“ab”。
        参数
        target - 要替换的char值的序列
        replacement - char值的替换顺序
        结果
        生成的字符串
        从以下版本开始:
        1.5
      • split

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

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

        当在此字符串的开始处存在正宽度匹配时,在结果数组的开始处包含空的前导子字符串。 开始时的零宽度匹配不会产生这样的空的前导子串。

        limit参数控制应用模式的次数,因此影响生成的数组的长度。 如果极限n大于0,则模式最多应用n -1次,数组的长度不大于n ,数组的最后一个条目将包含超出最后一个匹配分隔符的所有输入。 如果n是非正的,那么模式将被应用到尽可能多的次数,并且数组可以有任何长度。 如果n为0,则模式将被应用尽可能多次,数组可以有任何长度,并且尾随的空字符串将被丢弃。

        例如,字符串"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", "", "" }
        o -2 { "b", "", ":and:f", "", "" }
        o 0 { "b", "", ":and:f" }

        调用此方法的形式str。 split( 正则表达式 , n )得到与表达式相同的结果

        Pattern.compile(regex).split(strn)
        参数
        regex - 分隔正则表达式
        limit - 结果阈值,如上所述
        结果
        通过将该字符串围绕给定的正则表达式的匹配来计算的字符串数组
        异常
        PatternSyntaxException - 如果正则表达式的语法无效
        从以下版本开始:
        1.4
        另请参见:
        Pattern
      • split

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

        该方法的工作原理是通过使用给定的表达式和极限参数为零调用双参数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的副本组成的新的字符串,并附有指定的delimiter的副本。
        For example,
        
             String message = String.join("-", "Java", "is", "cool");
             // message returned is: "Java-is-cool"
         
        请注意,如果元素为空,则添加"null"
        参数
        delimiter - 分隔每个元素的分隔符
        elements - 要加入的元素。
        结果
        一个新的 String ,其由所述的 elements由分离 delimiter
        异常
        NullPointerException - 如果 delimiterelementsnull
        从以下版本开始:
        1.8
        另请参见:
        StringJoiner
      • join

        public static String join​(CharSequence delimiter,
                                  Iterable<? extends CharSequence> elements)
        返回一个新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连接在一起。
        结果
        一个新的 Stringelements参数组成
        异常
        NullPointerException - 如果 delimiterelementsnull
        从以下版本开始:
        1.8
        另请参见:
        join(CharSequence,CharSequence...)StringJoiner
      • toLowerCase

        public String toLowerCase​(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) capiotacapchi capthetacapupsil capsigma iotachi thetaupsilon sigma 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)
        将此String所有字符转换为大写,使用给定的Locale的规则。 案例映射基于由Character类指定的Unicode标准版本。 由于情况映射并不总是1:1的字符映射,所以产生的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​()
        返回一个字符串,其值为此字符串,并删除任何前导和尾随空格。

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

        否则,如果字符串中没有字符大于'\u0020'的字符,则返回表示空字符串的String对象。

        否则,令k为代码大于'\u0020'的字符串中第一个字符的索引,并且m为代码大于'\u0020'的字符串中最后一个字符的索引。 将返回一个String对象,表示此字符串的子字符串,以索引k处的字符开始,以索引m this.substring(k, m + 1)的字符结束,结果为this.substring(k, m + 1)

        此方法可用于从字符串的开始和结尾修剪空格(如上定义)。

        结果
        一个字符串,其值是此字符串,除去任何前导和尾随空格,或者如果该字符串没有前导或尾随的空格,则为该字符串。
      • 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
      • codePoints

        public IntStream codePoints​()
        从此序列返回码流值。 在序列中遇到的任何代理对被组合,如同通过Character.toCodePoint一样 ,并将结果传递给流。 任何其他代码单元,包括普通的BMP字符,未配对的代理和未定义的代码单元,都被零扩展到int值,然后传递给流。
        Specified by:
        codePoints在接口 CharSequence
        结果
        Unicode序列的IntStream从这个序列中指向
      • 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 - 如果格式字符串包含非法语法,则与给定参数不兼容的格式说明符,给定格式字符串的参数不足或其他非法条件。 有关所有可能的格式化错误的规范,请参阅格式化程序类规范的Details部分。
        从以下版本开始:
        1.5
        另请参见:
        Formatter
      • format

        public static String format​(Locale l,
                                    String format,
                                    Object... args)
        使用指定的区域设置,格式字符串和参数返回格式化的字符串。
        参数
        l - 格式化期间应用的locale 如果lnull则不应用本地化。
        format - A format string
        args - 格式字符串中格式说明符引用的参数。 如果比格式说明符更多的参数,额外的参数将被忽略。 参数的数量是可变的,可能为零。 参数的最大数量受限于由The Java™ Virtual Machine Specification定义的Java数组的最大维度。 一个null参数的行为取决于conversion
        结果
        格式化的字符串
        异常
        IllegalFormatException - 如果格式字符串包含非法语法,则与给定参数不兼容的格式说明符,给定格式字符串的参数不足或其他非法条件。 有关所有可能的格式化错误的规范,请参阅格式化程序类规范的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 - 字符数组。
        结果
        一个包含字符数组的字符的 String
      • valueOf

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

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

        参数
        data - 字符数组。
        offset - 子阵列的初始偏移量。
        count - 子阵列的长度。
        结果
        一个 String ,其中包含字符数组的指定子阵列的字符。
        异常
        IndexOutOfBoundsException - 如果 offset为负数,或 count为负数,或 offset+count大于 data.length
      • copyValueOf

        public static String copyValueOf​(char[] data,
                                         int offset,
                                         int count)
        参数
        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 - a boolean
        结果
        如果参数为true ,则返回等于"true"的字符串; 否则返回等于"false"的字符串。
      • valueOf

        public static String valueOf​(char c)
        返回 char参数的字符串表示形式。
        参数
        c - a char
        结果
        长度为 1的字符串包含其单个字符的参数 c
      • valueOf

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

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

        参数
        i - a 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私下维护。

        当调用intern方法时,如果池已经包含与equals(Object)方法确定的等于String对象的字符串,则返回来自池的字符串。 否则,此String对象将添加到池中,并返回对此String对象的引用。

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

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

        结果
        一个字符串与该字符串具有相同的内容,但保证来自一个唯一的字符串池。
        See The Java™ Language Specification:
        3.10.5字符串字面量