Module  java.base
软件包  java.lang

Class StringBuilder

  • All Implemented Interfaces:
    SerializableAppendableCharSequence


    public final class StringBuilder
    extends Object
    implements Serializable, CharSequence
    一个可变的字符序列。 该类提供了一个与StringBuffer兼容的API,但不能保证同步。 该类被设计为在字符串缓冲区被单个线程使用的地方(作为一般情况)用作StringBuffer替代替代。 在可能的情况下,建议使用这个类别优先于StringBuffer因为它在大多数实施中将更快。

    一个StringBuilder的主要操作是appendinsert方法,它们是重载的,以便接受任何类型的数据。 每个都有效地将给定的数据转换为字符串,然后将该字符串的字符附加或插入字符串构建器。 append方法总是在构建器的末尾添加这些字符; insert方法将字符添加到指定点。

    例如,如果z引用当前内容为“ start ”的字符串构建器对象,那么方法调用z.append("le")将导致字符串构建器包含“ startle ”,而z.insert(4, "le")会将字符串构建器更改为包含“ starlet ”。

    一般情况下,如果某人是指的一个实例StringBuilder ,然后sb.append(x)具有相同的效果sb.insert(sb.length(), x)

    每个字符串构建器都具有容量。 只要字符串构建器中包含的字符序列的长度不超过容量,则不需要分配新的内部缓冲区。 如果内部缓冲区溢出,则会自动变大。

    StringBuilder实例不能安全使用多线程。 如果需要同步,那么建议使用StringBuffer

    除非另有说明,否则将null参数传递给null中的构造函数或方法将导致抛出NullPointerException

    从以下版本开始:
    1.5
    另请参见:
    StringBufferStringSerialized Form
    • 构造方法摘要

      构造方法  
      Constructor 描述
      StringBuilder​()
      构造一个没有字符的字符串构建器,初始容量为16个字符。
      StringBuilder​(int capacity)
      构造一个没有字符的字符串构建器,以及由 capacity参数指定的初始容量。
      StringBuilder​(CharSequence seq)
      构造一个字符串构建器,其中包含与指定的 CharSequence相同的字符。
      StringBuilder​(String str)
      构造一个初始化为指定字符串内容的字符串构建器。
    • 构造方法详细信息

      • StringBuilder

        public StringBuilder​()
        构造一个没有字符的字符串构建器,初始容量为16个字符。
      • StringBuilder

        public StringBuilder​(int capacity)
        构造一个没有字符的字符串构建器,以及由 capacity参数指定的初始容量。
        参数
        capacity - 初始容量。
        异常
        NegativeArraySizeException - 如果 capacity参数小于 0
      • StringBuilder

        public StringBuilder​(String str)
        构造一个初始化为指定字符串内容的字符串构建器。 字符串构建器的初始容量为16加上字符串参数的长度。
        参数
        str - 缓冲区的初始内容。
      • StringBuilder

        public StringBuilder​(CharSequence seq)
        构造一个字符串构建器,其中包含与指定的CharSequence相同的字符。 字符串构建器的初始容量为16加上CharSequence参数的长度。
        参数
        seq - 要复制的顺序。
    • 方法详细信息

      • append

        public StringBuilder append​(Object obj)
        追加Object参数的字符串表示形式。

        整体效果就好像通过方法String.valueOf(Object)将参数转换为字符串,并且该字符串的字符然后是该字符序列的appended

        参数
        obj - 一个 Object
        结果
        对这个对象的引用。
      • append

        public StringBuilder append​(String str)
        将指定的字符串附加到此字符序列。

        附加String参数的字符,以便String参数的长度增加此序列的长度。 如果strnull ,则附加四个字符"null"

        在执行append方法之前,让n为该字符序列的长度。 那么如果k小于n ,则新字符序列中索引k处的字符等于旧字符序列中索引k处的字符; 否则,它等于参数str中的索引kn处的字符。

        参数
        str - 一个字符串。
        结果
        对这个对象的引用。
      • append

        public StringBuilder append​(StringBuffer sb)
        追加指定的StringBuffer到这个序列。

        按照序列的顺序追加StringBuffer参数的字符,将该序列的长度增加到参数的长度。 如果sbnull ,则该序列附加四个字符"null"

        在执行append方法之前,让n为该字符序列的长度。 那么如果k小于n ,则新字符序列中索引k处的字符等于旧字符序列中索引k处的字符; 否则,它等于参数sb中的索引kn处的字符。

        参数
        sb - 附加的 StringBuffer
        结果
        对这个对象的引用。
      • append

        public StringBuilder append​(CharSequence s)
        描述从接口Appendable复制
        将指定的字符序列追加到此Appendable

        根据哪个类实现字符序列csq ,整个序列可能不被附加。 例如,如果csq是一个CharBuffer则附加的子序列由缓冲区的位置和限制来定义。

        Specified by:
        append在接口 Appendable
        参数
        s - 要追加的字符序列。 如果csqnull ,则该"null"可附加四个字符"null"
        结果
        参考这个 Appendable
      • append

        public StringBuilder append​(CharSequence s,
                                    int start,
                                    int end)
        追加指定的序列CharSequence序列。

        从索引start开始的参数s字符按顺序附加到该序列的内容,直到(排他)索引end 该序列的长度增加了end - start的值。

        在执行append方法之前,让n为该字符序列的长度。 那么如果k小于n ,则该字符序列中的索引k处的字符变得等于该序列中索引k处的字符; 否则,它等于参数s中的索引k + start-n处的s

        如果snull ,则该方法将字符附加为s参数是包含四个字符"null"的序列。

        Specified by:
        append在接口 Appendable
        参数
        s - 要追加的序列。
        start - 要追加的子序列的起始索引。
        end - 要追加的子序列的结束索引。
        结果
        对这个对象的引用。
        异常
        IndexOutOfBoundsException - 如果 start为负数,或 start大于 endend大于 s.length()
      • append

        public StringBuilder append​(char[] str)
        char数组参数的字符串表示追加到此序列。

        数组参数的字符按顺序附加到此序列的内容。 该序列的长度增加参数的长度。

        整体效果就好像通过方法String.valueOf(char[])将参数转换为字符串,并且该字符串的字符然后是该字符序列的appended

        参数
        str - 要附加的字符。
        结果
        对这个对象的引用。
      • append

        public StringBuilder append​(char[] str,
                                    int offset,
                                    int len)
        char数组参数的子阵列的字符串表示附加到此序列。

        从索引offset开始的char阵列str字符按顺序附加到该序列的内容。 该序列的长度增加值为len

        总体效果就好像通过方法String.valueOf(char[],int,int)将参数转换为字符串,并且该字符串的字符然后是这个字符序列的appended

        参数
        str - 要附加的字符。
        offset -第一的指数 char追加。
        len - 要追加的 char的数量。
        结果
        对这个对象的引用。
        异常
        IndexOutOfBoundsException - 如果是 offset < 0len < 0offset+len > str.length
      • append

        public StringBuilder append​(boolean b)
        boolean参数的字符串表示追加到序列中。

        整体效果就好像通过方法String.valueOf(boolean)将参数转换为字符串,并且该字符串的字符然后是该字符序列的appended

        参数
        b - a boolean
        结果
        对这个对象的引用。
      • append

        public StringBuilder append​(char c)
        char参数的字符串表示附加到此序列。

        该参数附加到此序列的内容。 该序列的长度增加1

        整体效果就好像通过方法String.valueOf(char)将参数转换为字符串,该字符串中的字符然后是这个字符序列的appended

        Specified by:
        append在接口 Appendable
        参数
        c - a char
        结果
        对这个对象的引用。
      • append

        public StringBuilder append​(int i)
        int参数的字符串表示追加到此序列。

        整体效果就好像通过方法String.valueOf(int)将参数转换为字符串,并且该字符串的字符然后是该字符序列的appended

        参数
        i - 一个 int
        结果
        对这个对象的引用。
      • append

        public StringBuilder append​(long lng)
        long参数的字符串表示附加到此序列。

        整体效果就好像通过方法String.valueOf(long)将参数转换为字符串,并且该字符串的字符然后是该字符序列的appended

        参数
        lng - a long
        结果
        对这个对象的引用。
      • append

        public StringBuilder append​(float f)
        float参数的字符串表示法附加到此序列。

        整体效果就好像通过方法String.valueOf(float)将参数转换为字符串,并且该字符串的字符然后是这个字符序列的appended

        参数
        f - a float
        结果
        对这个对象的引用。
      • append

        public StringBuilder append​(double d)
        double参数的字符串表示追加到此序列。

        整体效果就好像通过方法String.valueOf(double)将参数转换为字符串,并且该字符串的字符然后是该字符序列的appended

        参数
        d - a double
        结果
        对这个对象的引用。
      • appendCodePoint

        public StringBuilder appendCodePoint​(int codePoint)
        codePoint参数的字符串表示追加到此序列。

        该参数附加到此序列的内容。 该序列的长度增加Character.charCount(codePoint)

        整体效果就好像通过方法Character.toChars(int)将参数转换为char数组,并且该数组中的字符然后是该字符序列的appended

        参数
        codePoint - 一个Unicode代码点
        结果
        对这个对象的引用。
        从以下版本开始:
        1.5
      • delete

        public StringBuilder delete​(int start,
                                    int end)
        删除此序列的子字符串中的字符。 子字符串从指定的start开始,并扩展到索引号为end - 1的字符,如果不存在这样的字符,则扩展到序列的末尾。 如果start等于end ,则不作任何更改。
        参数
        start - 开始索引,包括。
        end - 结束索引,独家。
        结果
        这个对象。
        异常
        StringIndexOutOfBoundsException - 如果 start为负数,大于 length()或大于 end
      • deleteCharAt

        public StringBuilder deleteCharAt​(int index)
        按照此顺序删除指定位置的char 该序列缩短了一个char

        注意:如果给定索引处的字符是补充字符,则此方法不会删除整个字符。 如果需要正确处理补充字符,请通过致电Character.charCount(thisSequence.codePointAt(index))确定charCharacter.charCount(thisSequence.codePointAt(index)) ,其中thisSequence为该序列。

        参数
        index - 索引 char删除
        结果
        这个对象。
        异常
        StringIndexOutOfBoundsException - 如果 index为负数或大于或等于 length()
      • replace

        public StringBuilder replace​(int start,
                                     int end,
                                     String str)
        将此序列的子字符串中的字符替换为指定的String字符。 子字符串从指定的start开始,并扩展到索引号为end - 1的字符,如果不存在这样的字符,则扩展到序列的末尾。 首先删除子字符串中的字符,然后在String插入指定的start (如果需要,此序列将被延长以容纳指定的字符串。)
        参数
        start - 开始索引,包括。
        end - 结束索引,独家。
        str - 将替换以前内容的字符串。
        结果
        这个对象。
        异常
        StringIndexOutOfBoundsException - 如果 start为负,大于 length() ,或大于 end
      • insert

        public StringBuilder insert​(int index,
                                    char[] str,
                                    int offset,
                                    int len)
        str数组参数的子阵列的字符串表示插入到此序列中。 子阵列从指定的offset开始,扩展len char s。 子阵列的字符在index所示的位置被插入到该序列中。 该序列的长度增加len char s。
        参数
        index - 插入子阵列的位置。
        str - A char数组。
        offset - 要插入的子阵列中的第一个 char的索引。
        len - 要插入的子阵列中的 char的数量。
        结果
        这个对象
        异常
        StringIndexOutOfBoundsException - 如果 index为负数或大于 length() ,或 offsetlen为负数,或 (offset+len)大于 str.length
      • insert

        public StringBuilder insert​(int offset,
                                    Object obj)
        Object参数的字符串表示插入到此字符序列中。

        整体效果就好像第二个参数通过方法String.valueOf(Object)转换为一个字符串,并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。

        offset参数必须大于或等于0 ,小于或等于此序列的length

        参数
        offset - 偏移。
        obj - a Object
        结果
        对这个对象的引用。
        异常
        StringIndexOutOfBoundsException - 如果偏移无效。
      • insert

        public StringBuilder insert​(int offset,
                                    String str)
        将字符串插入到此字符序列中。

        String参数的字符按顺序插入到指定偏移量的该序列中,向上移动原始位于该位置的任何字符,并将该序列的长度增加到参数的长度。 如果strnull ,则四个字符"null"被插入到该序列中。

        新字符序列中索引k处的字符等于:

        • 如果k小于offset ,则旧字符序列中的索引k处的字符
        • 在索引k处的字符-offset在参数str ,如果k不小于offset但小于offset+str.length()
        • 在旧字符序列中的索引k -str.length()处的字符,如果k不小于offset+str.length()

        offset参数必须大于或等于0 ,小于或等于此序列的length

        参数
        offset - 偏移。
        str - 一个字符串。
        结果
        对这个对象的引用。
        异常
        StringIndexOutOfBoundsException - 如果偏移量无效。
      • insert

        public StringBuilder insert​(int offset,
                                    char[] str)
        在此序列中插入char数组参数的字符串表示形式。

        数组参数的字符在offset指示的位置插入到该序列的内容中。 该序列的长度增加参数的长度。

        总体效果就好像第二个参数通过方法String.valueOf(char[])转换为一个字符串,并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。

        offset参数必须大于或等于0 ,小于或等于此序列的length

        参数
        offset - 偏移量。
        str - 一个字符数组。
        结果
        对这个对象的引用。
        异常
        StringIndexOutOfBoundsException - 如果偏移无效。
      • insert

        public StringBuilder insert​(int dstOffset,
                                    CharSequence s)
        在此序列中插入指定的CharSequence

        CharSequence参数的字符按顺序插入到指定偏移量的该序列中,向上移动原始位于该位置的任何字符,并将该序列的长度增加到参数s的长度。

        该方法的结果与调用该对象的insert (dstOffset,s,0,s.length())方法完全相同

        如果snull ,则四个字符"null"被插入到该序列中。

        参数
        dstOffset - 偏移量。
        s - 要插入的序列
        结果
        对这个对象的引用。
        异常
        IndexOutOfBoundsException - 如果偏移无效。
      • insert

        public StringBuilder insert​(int dstOffset,
                                    CharSequence s,
                                    int start,
                                    int end)
        在该序列中插入指定的CharSequence序列。

        参数的子序列s通过指定startend被插入,以便成在指定的目的地偏移该序列中,该位置上述最初向上运动的任何字符。 该序列的长度增加end - start

        该序列中索引k处的字符等于:

        • 如果k小于dstOffset ,则该序列中索引k处的字符
        • 参数s中索引k +start-dstOffset处的字符,如果k大于或等于dstOffset但小于dstOffset+end-start
        • 在该序列中的索引k -(end-start)处的字符,如果k大于或等于dstOffset+end-start

        dstOffset参数必须大于或等于0 ,小于或等于该序列的length

        起始参数必须是非负数,不得大于end

        结束参数必须大于或等于start ,小于或等于s的长度。

        如果snull ,则该方法插入字符,就像s参数是包含四个字符"null"的序列"null"

        参数
        dstOffset - 此序列中的偏移量。
        s - 要插入的序列。
        start - 插入子序列的起始索引。
        end - 要插入的子序列的结束索引。
        结果
        对这个对象的引用。
        异常
        IndexOutOfBoundsException - 如果 dstOffset为负数或大于 this.length() ,或 startend为负数,或 start大于 endend大于 s.length()
      • insert

        public StringBuilder insert​(int offset,
                                    boolean b)
        boolean参数的字符串表示插入到此序列中。

        整体效果就好像第二个参数通过方法String.valueOf(boolean)转换为一个字符串,并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。

        offset参数必须大于或等于0 ,小于或等于此序列的length

        参数
        offset - 偏移。
        b - a boolean
        结果
        对这个对象的引用。
        异常
        StringIndexOutOfBoundsException - 如果偏移量无效。
      • insert

        public StringBuilder insert​(int offset,
                                    char c)
        char参数的字符串表示插入到此序列中。

        总体效果就好像第二个参数通过方法String.valueOf(char)转换为一个字符串,并且该字符串中的字符然后是inserted到指定的偏移量的这个字符序列。

        offset参数必须大于或等于0 ,并小于或等于此序列的length

        参数
        offset - 偏移。
        c - a char
        结果
        对这个对象的引用。
        异常
        IndexOutOfBoundsException - 如果偏移量无效。
      • insert

        public StringBuilder insert​(int offset,
                                    int i)
        将第二个int参数的字符串表示插入到此序列中。

        整体效果就好像通过方法String.valueOf(int)将第二个参数转换为字符串,并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。

        offset参数必须大于或等于0 ,小于或等于此序列的length

        参数
        offset - 偏移量。
        i - a int
        结果
        对这个对象的引用。
        异常
        StringIndexOutOfBoundsException - 如果偏移无效。
      • insert

        public StringBuilder insert​(int offset,
                                    long l)
        在此序列中插入long参数的字符串表示形式。

        总体效果就好像第二个参数通过方法String.valueOf(long)转换为一个字符串,并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。

        offset参数必须大于或等于0 ,小于或等于此序列的length

        参数
        offset - 偏移量。
        l - a long
        结果
        对这个对象的引用。
        异常
        StringIndexOutOfBoundsException - 如果偏移量无效。
      • insert

        public StringBuilder insert​(int offset,
                                    float f)
        float参数的字符串表示插入到此序列中。

        总体效果就好像第二个参数通过方法String.valueOf(float)转换为一个字符串,并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。

        offset参数必须大于或等于0 ,并且小于或等于此序列的length

        参数
        offset - 偏移。
        f - a float
        结果
        对这个对象的引用。
        异常
        StringIndexOutOfBoundsException - 如果偏移无效。
      • insert

        public StringBuilder insert​(int offset,
                                    double d)
        double参数的字符串表示插入到此序列中。

        总体效果就好像第二个参数通过方法String.valueOf(double)转换为一个字符串,并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。

        offset参数必须大于或等于0 ,小于或等于此序列的length

        参数
        offset - 偏移。
        d - a double
        结果
        对这个对象的引用。
        异常
        StringIndexOutOfBoundsException - 如果偏移量无效。
      • indexOf

        public int indexOf​(String str)
        返回指定子字符串第一次出现的字符串内的索引。

        返回的索引是最小值k ,其中:

           this.toString().startsWith(str, k)  
        如果没有k值,则返回-1
        参数
        str - 要搜索的子字符串。
        结果
        第一次发生指定子串的索引,如果没有这种情况, -1
      • indexOf

        public int indexOf​(String str,
                           int fromIndex)
        返回指定子串的第一次出现的字符串中的索引,从指定的索引开始。

        返回的索引是最小值k ,其中:

           k >= Math.min(fromIndex, this.length()) && this.toString().startsWith(str, k)  
        如果没有k值,则返回-1
        参数
        str - 要搜索的子字符串。
        fromIndex - 从中开始搜索的索引。
        结果
        指定的子字符串的第一次出现的索引,从指定的索引开始,如果没有这种情况, -1
      • lastIndexOf

        public int lastIndexOf​(String str)
        返回指定子字符串最后一次出现的字符串中的索引。 空字符串“”的最后一次出现被认为发生在索引值this.length()

        返回的指数是k ,其中:

           this.toString().startsWith(str, k)  
        如果没有这样的价值k存在,那么-1返回。
        参数
        str - 要搜索的子字符串。
        结果
        指定子字符串的最后一次出现的索引,如果没有这种情况, -1
      • lastIndexOf

        public int lastIndexOf​(String str,
                               int fromIndex)
        返回指定子字符串的最后一次出现的字符串中的索引,从指定索引开始向后搜索。

        返回的指数是k

           k <= Math.min(fromIndex, this.length()) && this.toString().startsWith(str, k)  
        如果没有k值,则返回-1
        参数
        str - 要搜索的子字符串。
        fromIndex - 开始搜索的索引。
        结果
        指定子字符串的最后一次出现的索引,从指定的索引向后搜索,如果没有发生这种情况, -1
      • reverse

        public StringBuilder reverse​()
        导致该字符序列被序列的相反代替。 如果序列中包含任何替代对,则将它们视为单个字符进行反向操作。 因此,高低替代品的顺序从未被扭转过。 在执行reverse方法之前,让n为该字符序列的字符长度(不是char的长度)。 那么新字符序列中的索引k处的字符等于旧字符序列中的索引nk-1处的字符。

        请注意,相反的操作可能会导致在手术之前产生不配对的低代谢和高代谢的替代对。 例如,反转“\ uDC00 \ uD800”会生成“\ uD800 \ uDC00”,它是一个有效的代理对。

        结果
        对这个对象的引用。
      • toString

        public String toString​()
        返回表示此顺序中的数据的字符串。 新的String对象被分配和初始化以包含此对象当前表示的字符序列。 然后返回String 对此序列的后续更改不影响String的内容。
        Specified by:
        toString在接口 CharSequence
        结果
        这个字符序列的字符串表示。
      • length

        public int length​()
        返回长度(字符数)。
        Specified by:
        length在接口 CharSequence
        结果
        当前由此对象表示的字符序列的长度
      • capacity

        public int capacity​()
        返回当前容量。 容量是新插入字符可用的存储量,超过此值将进行分配。
        结果
        当前的容量
      • ensureCapacity

        public void ensureCapacity​(int minimumCapacity)
        确保容量至少等于规定的最小值。 如果当前容量小于参数,则会分配一个新的内部数组,容量更大。 新产能较大:
        • minimumCapacity论证。
        • 两倍的旧容量,加上2
        如果minimumCapacity参数为非正态,则此方法不执行任何操作,只需返回。 请注意,此对象的后续操作可以将实际容量降低到低于此处所请求的容量。
        参数
        minimumCapacity - 最小所需容量。
      • trimToSize

        public void trimToSize​()
        尝试减少用于字符序列的存储。 如果缓冲区大于保持其当前字符序列所需的缓冲区,则可以将其调整大小以变得更加空间有效。 调用此方法可能但不是要求影响后续调用capacity()方法返回的值。
      • setLength

        public void setLength​(int newLength)
        设置字符序列的长度。 该序列被更改为一个新的字符序列,其长度由参数指定。 对于小于每非负索引k newLength ,在新的字符序列的索引k处的字符是相同的在旧序列索引k如果k小于原字符序列的长度的字符; 否则,它是空字符'\u0000' 换句话说,如果newLength参数小于当前长度,则长度将更改为指定的长度。

        如果newLength参数大于或等于当前长度,则会附加足够的空字符( '\u0000' ),以使长度成为newLength参数。

        newLength参数必须大于或等于0

        参数
        newLength - 新的长度
        异常
        IndexOutOfBoundsException - 如果 newLength参数为负数。
      • charAt

        public char charAt​(int index)
        返回指定索引处的此序列中的char值。 第一个char值是索引0 ,下一个索引为1 ,依此类推,就像在数组索引中一样。

        索引参数必须大于或等于0 ,并小于此序列的长度。

        如果索引指定的char值为surrogate ,则返回替代值。

        Specified by:
        charAt在接口 CharSequence
        参数
        index - index的指数 char
        结果
        指定的指数为 char
        异常
        IndexOutOfBoundsException - 如果 index为负数或大于或等于 length()
      • codePointAt

        public int codePointAt​(int index)
        返回指定索引处的字符(Unicode代码点)。 索引指的是char值(Unicode代码单位),范围从0length() - 1

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

        参数
        index - 索引为 char
        结果
        字符的代码点值在 index
        异常
        IndexOutOfBoundsException - 如果 index参数为负数或不小于此序列的长度。
      • codePointBefore

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

        如果char(index - 1)处于低代理区间,则(index - 2)不为负,而char(index - 2) ,处于高替代范围,则返回替代对的补码代码值。 如果char在值index - 1是未配对的低代理或一个高代理,则返回所述替代值。

        参数
        index - 应该返回的代码点之后的索引
        结果
        Unicode代码点值在给定索引之前。
        异常
        IndexOutOfBoundsException - 如果 index参数小于1或大于此序列的长度。
      • codePointCount

        public int codePointCount​(int beginIndex,
                                  int endIndex)
        返回此序列指定文本范围内的Unicode代码点数。 文本范围始于指定beginIndex并延伸到char在索引endIndex - 1 因此,文本范围的长度( char秒)为endIndex-beginIndex 该序列中的未配对代理计数为每个代码点。
        参数
        beginIndex - 索引到第一个 char的文本范围。
        endIndex - 最后一个 char之后的索引文本范围。
        结果
        指定文本范围内的Unicode代码点数
        异常
        IndexOutOfBoundsException - 如果 beginIndex为负数,或 endIndex大于此序列的长度,或 beginIndex大于 endIndex
      • offsetByCodePoints

        public int offsetByCodePoints​(int index,
                                      int codePointOffset)
        返回该序列中与indexcodePointOffset代码点偏移的索引。 indexcodePointOffset给出的文本范围内的非配对替代品作为每个代码点。
        参数
        index - 要偏移的索引
        codePointOffset - 代码点的偏移量
        结果
        该序列中的索引
        异常
        IndexOutOfBoundsException - 如果 index为负或大于该序列的长度,或者如果 codePointOffset为正,并且由 index开始的子 index具有少于 codePointOffset码点,或者如果 codePointOffset为负,并且 index之前的子 index小于绝对值 codePointOffset代码点。
      • getChars

        public void getChars​(int srcBegin,
                             int srcEnd,
                             char[] dst,
                             int dstBegin)
        字符从该序列复制到目标字符数组dst 要复制的第一个字符是索引srcBegin ; 要复制的最后一个字符在索引srcEnd-1 要复制的字符总数为srcEnd-srcBegin 字符被复制到dst的子阵列,从索引dstBegin开始,以索引结尾:
           dstbegin + (srcEnd-srcBegin) - 1  
        参数
        srcBegin - 以此偏移量开始复制。
        srcEnd - 在此偏移处停止复制。
        dst - 将数据复制到的数组。
        dstBegin - 偏移到 dst
        异常
        IndexOutOfBoundsException - 如果满足以下条件:
        • srcBegin为负数
        • dstBegin是否定的
        • srcBegin参数大于srcEnd参数。
        • srcEnd大于this.length()
        • dstBegin+srcEnd-srcBegin大于dst.length
      • setCharAt

        public void setCharAt​(int index,
                              char ch)
        指定索引处的字符设置为ch 该序列被改变以表示一个新的字符序列,其是相同的原字符序列,不同之处在于它包含字符ch在位置index

        索引参数必须大于或等于0 ,并小于此序列的长度。

        参数
        index - 要修改的字符的索引。
        ch - 新角色。
        异常
        IndexOutOfBoundsException - 如果 index为负数或大于或等于 length()
      • substring

        public String substring​(int start)
        返回一个新的String ,其中包含此字符序列中当前包含的字符的子序列。 子串从指定的索引开始,并延伸到该序列的末尾。
        参数
        start - 开始索引,包括。
        结果
        新的字符串。
        异常
        StringIndexOutOfBoundsException - 如果 start小于零或大于此对象的长度。
      • subSequence

        public CharSequence subSequence​(int start,
                                        int end)
        返回一个新的字符序列,该序列是该序列的子序列。

        调用此方法的形式

           sb.subSequence(begin,&nbsp;end) 
        行为与调用完全相同
           sb.substring(begin,&nbsp;end) 
        提供这种方法,使该类可以实现CharSequence接口。
        Specified by:
        subSequence在接口 CharSequence
        参数
        start - 开始索引,包括。
        end - 结束索引,独家。
        结果
        指定的子序列。
        异常
        IndexOutOfBoundsException - 如果 startend为负数,如果 end大于 length() ,或者如果 start大于 end
      • substring

        public String substring​(int start,
                                int end)
        返回一个新的String ,其中包含此序列中当前包含的字符的子序列。 子串从指定的start开始,并扩展到索引号为end - 1的字符。
        参数
        start - 开始索引,包括。
        end - 结束索引,独家。
        结果
        新的字符串。
        异常
        StringIndexOutOfBoundsException - 如果 startend为负数或大于 length() ,或 start大于 end
      • chars

        public IntStream chars​()
        返回一个int的数据流, int零序扩展char值。 映射到surrogate code point的任何字符通过未解释的方式传递。

        当终端流操作开始时(特别地,对于可变序列,流的分流器是late-binding ),流与该序列绑定。 如果序列在该操作期间被修改,则结果是未定义的。

        Specified by:
        chars在接口 CharSequence
        结果
        这个序列中的char值的IntStream
        从以下版本开始:
        9
      • codePoints

        public IntStream codePoints​()
        从此序列返回码流值。 在序列中遇到的任何替代对被组合,如同通过Character.toCodePoint ,并将结果传递给流。 任何其他代码单元,包括普通的BMP字符,未配对的代理和未定义的代码单元,都将零扩展到int值,然后传递给流。

        当终端流操作开始时(具体来说,对于可变序列,流的分流器是late-binding ),流与该序列绑定。 如果序列在该操作期间被修改,则结果是未定义的。

        Specified by:
        codePoints在接口 CharSequence
        结果
        Unicode序列的IntStream从这个序列中指向
        从以下版本开始:
        9