Module  java.base
软件包  java.nio

Class CharBuffer

  • All Implemented Interfaces:
    AppendableCharSequenceComparable<CharBuffer>Readable


    public abstract class CharBuffer
    extends Buffer
    implements Comparable<CharBuffer>, Appendable, CharSequence, Readable
    一个char缓冲区。

    这个类在char缓冲区中定义了四类操作:

    • 绝对和相对的getput读写单个字符的方法;

    • 相对bulk get方法将连续的字符序列从该缓冲区传输到数组中;

    • 相对bulk put方法,将char数组,字符串或其他一些其他char缓冲区中的字符串连续传输到此缓冲区中;

    • 一个方法compacting一个char缓冲区。

    Char缓冲区可以由allocation创建,它为缓冲区的内容分配空间, wrapping将现有的char数组或字符串分配到缓冲区中,或者通过创建现有字节缓冲区的view

    像一个字节缓冲区一样,char缓冲区是direct or non-direct 通过wrap方法创建的char缓冲区将是非直接的。 作为字节缓冲区视图创建的char缓冲区将是直接的,只有当字节缓冲区本身是直接的。 char缓冲区是否直接可以通过调用isDirect方法来确定。

    该类实现CharSequence接口,使得可以在字符序列被接受的地方使用字符缓冲器,例如在正则表达式包java.util.regex

    指定此类中没有值返回值的方法返回调用它们的缓冲区。 这允许方法调用被链接。 语句序列

     cb.put("text/");
     cb.put(subtype);
     cb.put("; charset=");
     cb.put(enc);
    例如,可以用单个语句来替换
     cb.put("text/").put(subtype).put("; charset=").put(enc);
    从以下版本开始:
    1.4
    • 方法详细信息

      • allocate

        public static CharBuffer allocate​(int capacity)
        分配一个新的char缓冲区。

        新缓冲区的位置将为零,其限制将为其容量,其标记将不定义,其每个元素将被初始化为零,其字节顺序将为底层硬件的native order 它将有一个backing array ,其array offset将为零。

        参数
        capacity - 新的缓冲区的容量,字符
        结果
        新的char缓冲区
        异常
        IllegalArgumentException - 如果 capacity是负整数
      • wrap

        public static CharBuffer wrap​(char[] array,
                                      int offset,
                                      int length)
        将一个char数组包装到缓冲区中。

        新缓冲区将由给定的char数组支持; 也就是说,对缓冲区的修改将导致数组被修改,反之亦然。 新的缓冲区容量将为array.length ,其位置将为offset ,其限制将为offset + length ,其标记将不定义,其字节顺序将为底层硬件的native order 它的backing array将是给定的数组,其array offset将为零。

        参数
        array - 将返回新缓冲区的数组
        offset - 要使用的子阵列的偏移量; 必须是非负数,不得大于array.length 新缓冲区的位置将被设置为此值。
        length - 要使用的子阵列的长度; 必须是非负数,不得大于array.length - offset 新缓冲区的限制将设置为offset + length
        结果
        新的char缓冲区
        异常
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
      • wrap

        public static CharBuffer wrap​(char[] array)
        将一个char数组包装到缓冲区中。

        新缓冲区将由给定的char数组支持; 也就是说,对缓冲区的修改将导致数组被修改,反之亦然。 新的缓冲区的容量和限制将为array.length ,其位置将为零,其标记将不定义,其字节顺序将为底层硬件的native order backing array将是给定的数组,其array offset将为零。

        参数
        array - 将返回此缓冲区的数组
        结果
        新的char缓冲区
      • read

        public int read​(CharBuffer target)
                 throws IOException
        尝试将字符读入指定的字符缓冲区。 缓冲区用作字符存储库:唯一的更改是put操作的结果。 不执行缓冲器的翻转或倒带。
        Specified by:
        read在接口 Readable
        参数
        target - 读取字符的缓冲区
        结果
        添加到缓冲区的字符数,如果此字符源结束,则为-1
        异常
        IOException - 如果发生I / O错误
        NullPointerException - 如果目标为null
        ReadOnlyBufferException - 如果目标是只读缓冲区
        从以下版本开始:
        1.5
      • wrap

        public static CharBuffer wrap​(CharSequence csq,
                                      int start,
                                      int end)
        将字符序列包装到缓冲区中。

        新的只读缓冲区的内容将是给定字符序列的内容。 缓冲区的容量将为csq.length() ,其位置将为start ,其限制将为end ,其标记将不定。

        参数
        csq - 要创建新字符缓冲区的字符序列
        start - 要使用的第一个字符的索引; 必须是非负数,不得大于csq.length() 新缓冲区的位置将被设置为此值。
        end - 要使用的最后一个字符后面的字符的索引; 必须不小于start ,不得大于csq.length() 新缓冲区的限制将被设置为此值。
        结果
        新的字符缓冲区
        异常
        IndexOutOfBoundsException - 如果 startend参数的前提条件不成立
      • wrap

        public static CharBuffer wrap​(CharSequence csq)
        将字符序列包装到缓冲区中。

        新的只读缓冲区的内容将是给定字符序列的内容。 新增缓存的容量和限制将为csq.length() ,其位置将为零,其标志将不明确。

        参数
        csq - 要创建新字符缓冲区的字符序列
        结果
        新的字符缓冲区
      • slice

        public abstract CharBuffer slice​()
        创建一个新的char缓冲区,其内容是此缓冲区内容的共享子序列。

        新缓冲区的内容将从此缓冲区的当前位置开始。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的位置将为零,其容量和限制将是此缓冲区中剩余的字符数,其标记将不定义,并且其字节顺序将与此缓冲区的字节顺序相同。 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        Specified by:
        sliceBuffer
        结果
        新的char缓冲区
      • duplicate

        public abstract CharBuffer duplicate​()
        创建一个新的char缓冲区,共享此缓冲区的内容。

        新缓冲区的内容将是这个缓冲区的内容。 对这个缓冲区内容的更改将在新的缓冲区中可见,反之亦然; 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的容量,限制,位置,标记值和字节顺序将与此缓冲区的容量相同。 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        Specified by:
        duplicateBuffer
        结果
        新的char缓冲区
      • asReadOnlyBuffer

        public abstract CharBuffer asReadOnlyBuffer​()
        创建一个新的只读char缓冲区,共享此缓冲区的内容。

        新缓冲区的内容将是这个缓冲区的内容。 这个缓冲区内容的更改将在新的缓冲区中显示; 但是,新的缓冲区本身将是只读的,不允许修改共享内容。 两个缓冲区的位置,极限和标记值将是独立的。

        新缓冲区的容量,限制,位置,标记值和字节顺序将与此缓冲区的容量相同。

        如果这个缓冲区本身是只读的,那么这个方法的行为与duplicate方法完全相同。

        结果
        新的只读char缓冲区
      • get

        public abstract char get​()
        相对获取方法。 读取此缓冲区当前位置的字符,然后增加位置。
        结果
        在缓冲区的当前位置的char
        异常
        BufferUnderflowException - 如果缓冲区的当前位置不小于其限制
      • put

        public abstract CharBuffer put​(char c)
        相对放置(可选操作)

        将给定的字符写入当前位置的缓冲区,然后增加位置。

        参数
        c - c的字符
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区的当前位置不小于其限制
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • get

        public abstract char get​(int index)
        绝对获取方法。 读取给定索引的char。
        参数
        index - 从中读取char的索引
        结果
        给定索引的字符
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制
      • put

        public abstract CharBuffer put​(int index,
                                       char c)
        绝对put方法(可选操作)

        将给定的char写入给定索引的缓冲区。

        参数
        index - 将写入字符的索引
        c - 要写入的字符值
        结果
        这个缓冲区
        异常
        IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区限制
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • get

        public CharBuffer get​(char[] dst,
                              int offset,
                              int length)
        相对批量获取方法。

        此方法将chars从此缓冲区传输到给定的目标数组。 如果缓冲区中剩余的字符少于满足请求所需的字符数,即length > remaining() ,则不会传输字符并抛出BufferUnderflowException

        否则,此方法将length这个缓冲区的字符复制到给定的数组中,从该缓冲区的当前位置开始,并在数组中给定的偏移量。 此缓冲区的位置然后增加length

        换句话说,这种src.get(dst, off, len)形式的方法的调用与循环完全相同

           for (int i = off; i < off + len; i++) dst[i] = src.get():  
        除了它首先检查这个缓冲区中是否有足够的字符,并且它可能更有效率。
        参数
        dst - 要写入字符的数组
        offset - 要写入的第一个char的数组中的偏移量; 必须是非负数,不得大于dst.length
        length - 要写入给定数组的最大字符数; 必须是非负数,不得大于dst.length - offset
        结果
        这个缓冲区
        异常
        BufferUnderflowException - 如果此缓冲区中剩余的字符少于 length字符
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
      • get

        public CharBuffer get​(char[] dst)
        相对批量获取方法。

        此方法将chars从此缓冲区传输到给定的目标数组。 对这种src.get(a)形式的方法的调用与调用的方式完全相同

          src.get(a, 0, a.length) 
        参数
        dst - 目的数组
        结果
        这个缓冲区
        异常
        BufferUnderflowException - 如果此缓冲区中剩余的字符少于 length字符
      • put

        public CharBuffer put​(CharBuffer src)
        相对大容量put方法(可选操作)

        此方法将给定源缓冲区中剩余的字符传输到此缓冲区。 如果源缓冲区中存在的字符多于此缓冲区中的字符数,即src.remaining() > remaining() ,则不会传输字符并抛出BufferOverflowException

        否则,该方法将n = src.remaining()字符从给定缓冲区复制到此缓冲区,从每个缓冲区的当前位置开始。 然后将两个缓冲器的位置递增n

        换句话说,这种dst.put(src)形式的方法的调用与循环完全相同

          while (src.hasRemaining())
                 dst.put(src.get()); 
        除了它首先检查这个缓冲区中是否有足够的空间,并且它可能更有效率。
        参数
        src - 要读取字符的源缓冲区; 不能是这个缓冲区
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果源缓冲区中剩余字符的此缓冲区空间不足
        IllegalArgumentException - 如果源缓冲区是此缓冲区
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • put

        public CharBuffer put​(char[] src,
                              int offset,
                              int length)
        相对大容量put方法(可选操作)

        此方法将chars从给定的源数组传入此缓冲区。 如果从数组中复制的字符多于保留在此缓冲区中的字符数,即length > remaining() ,则不会传输字符并抛出BufferOverflowException

        否则,该方法length定数组中的length字符复制到此缓冲区中,从数组中给定的偏移量和此缓冲区的当前位置开始。 此缓冲区的位置然后增加length

        换句话说,这种dst.put(src, off, len)形式的方法的调用与循环完全相同

           for (int i = off; i < off + len; i++) dst.put(a[i]);  
        除了它首先检查这个缓冲区中是否有足够的空间,并且它可能更有效率。
        参数
        src - 要从中读取字符的数组
        offset - 要读取的第一个字符的数组中的偏移量; 必须是非负数,不得大于array.length
        length - 从给定数组读取的字符数; 必须是非负数,不得大于array.length - offset
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        IndexOutOfBoundsException - 如果 offsetlength参数的前提条件不成立
        ReadOnlyBufferException - 如果此缓冲区为只读
      • put

        public final CharBuffer put​(char[] src)
        相对大容量put方法(可选操作)

        此方法将给定源字符数组的整个内容传输到此缓冲区。 对这种dst.put(a)形式的方法的调用与调用的方式完全相同

          dst.put(a, 0, a.length) 
        参数
        src - 源数组
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • put

        public CharBuffer put​(String src,
                              int start,
                              int end)
        相对大容量put方法(可选操作)

        此方法将字符串从给定的字符串传输到此缓冲区。 如果要从字符串中复制的字符数多于保留在此缓冲区中的字符数,即end - start > remaining() ,则不会传输字符并抛出BufferOverflowException

        否则,此方法将给定字符串中的n = end - start字符复制到此缓冲区中,从给定的start索引和此缓冲区的当前位置开始。 然后将该缓冲器的位置增加n

        换句话说,这种形式为dst.put(src, start, end)方法的调用与dst.put(src, start, end)具有完全相同的效果

           for (int i = start; i < end; i++) dst.put(src.charAt(i));  
        除了它首先检查这个缓冲区中是否有足够的空间,并且它可能更有效率。
        参数
        src - 要从中读取字符的字符串
        start - 要读取的第一个字符串的字符串中的偏移量; 必须是非负数,不得大于string.length()
        end - 要读取的最后一个字符串的字符串中的偏移量,加1; 必须是非负数,不得大于string.length()
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区空间不足
        IndexOutOfBoundsException - 如果 startend参数的前提条件不成立
        ReadOnlyBufferException - 如果这个缓冲区是只读的
      • put

        public final CharBuffer put​(String src)
        相对大容量put方法(可选操作)

        此方法将给定源字符串的整个内容传输到此缓冲区。 这种dst.put(s)形式的方法的调用与调用的方式完全相同

          dst.put(s, 0, s.length()) 
        参数
        src - 源字符串
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        ReadOnlyBufferException - 如果此缓冲区是只读的
      • hasArray

        public final boolean hasArray​()
        告诉这个缓冲区是否由可访问的字符数组支持。

        如果此方法返回true则可以安全地调用arrayarrayOffset方法。

        Specified by:
        hasArrayBuffer
        结果
        true如果并且只有这个缓冲区由数组支持并且不是只读的
      • array

        public final char[] array​()
        返回支持此缓冲区的char数组(可选操作)

        对此缓冲区内容的修改将导致返回的数组的内容被修改,反之亦然。

        在调用此方法之前调用hasArray方法,以确保此缓冲区具有可访问的后台阵列。

        Specified by:
        arrayBuffer
        结果
        支持这个缓冲区的数组
        异常
        ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
        UnsupportedOperationException - 如果此缓冲区未由可访问阵列支持
      • arrayOffset

        public final int arrayOffset​()
        返回该缓冲区的缓冲区的第一个元素的背衬数组中的偏移量(可选操作)

        如果此缓冲区由数组支持,则缓冲区p对应于数组索引p + arrayOffset()

        在调用此方法之前调用hasArray方法,以确保此缓冲区具有可访问的后台阵列。

        Specified by:
        arrayOffsetBuffer
        结果
        缓冲区的第一个元素的缓冲区数组中的偏移量
        异常
        ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读
        UnsupportedOperationException - 如果此缓冲区未由可访问阵列支持
      • position

        public final CharBuffer position​(int newPosition)
        设置这个缓冲区的位置。 如果标记被定义并且大于新位置,则它被丢弃。
        重写:
        positionBuffer
        参数
        newPosition - 新的位置值; 必须是非负数,不得大于当前限制
        结果
        这个缓冲区
      • limit

        public final CharBuffer limit​(int newLimit)
        设置此缓冲区的限制。 如果位置大于新的限制,那么它被设置为新的限制。 如果标记被定义并且大于新限制,则它被丢弃。
        重写:
        limitBuffer
        参数
        newLimit - 新限制值; 必须是非负数,不大于此缓冲区的容量
        结果
        这个缓冲区
      • mark

        public final CharBuffer mark​()
        将此缓冲区的标记设置在其位置。
        重写:
        mark在类 Buffer
        结果
        这个缓冲区
      • reset

        public final CharBuffer reset​()
        将此缓冲区的位置重置为先前标记的位置。

        调用此方法既不会更改也不丢弃该标记的值。

        重写:
        resetBuffer
        结果
        这个缓冲区
      • clear

        public final CharBuffer clear​()
        清除此缓冲区。 位置设置为零,限制设置为容量,标记被丢弃。

        在使用一系列通道读取或放置操作填充此缓冲区之前调用此方法。 例如:

         buf.clear();     // Prepare buffer for reading
         in.read(buf);    // Read data

        该方法实际上并不会清除缓冲区中的数据,而是将其命名为它的确因为它最常用于情况也是如此。

        重写:
        clearBuffer
        结果
        这个缓冲区
      • flip

        public final CharBuffer flip​()
        翻转这个缓冲区。 该限制设置为当前位置,然后将该位置设置为零。 如果标记被定义,则它被丢弃。

        在通道读取或放置操作的序列之后,调用此方法来准备一系列通道写入或相对获取操作。 例如:

         buf.put(magic);    // Prepend header
         in.read(buf);      // Read data into rest of buffer
         buf.flip();        // Flip buffer
         out.write(buf);    // Write header + data to channel

        当将数据从一个地方传输到另一个地址时,该方法通常与compact方法结合使用。

        重写:
        flipBuffer
        结果
        这个缓冲区
      • rewind

        public final CharBuffer rewind​()
        倒带这个缓冲区。 位置设置为零,标记被丢弃。

        在通道写入或获取操作的序列之前调用此方法,假设已经设置了相应的限制。 例如:

         out.write(buf);    // Write remaining data
         buf.rewind();      // Rewind buffer
         buf.get(array);    // Copy data into array
        重写:
        rewind在类 Buffer
        结果
        这个缓冲区
      • compact

        public abstract CharBuffer compact​()
        压缩此缓冲区(可选操作)

        缓冲区当前位置和其限制(如果有的话)之间的字符将被复制到缓冲区的开头。 也就是说,索引p = position()处的字符被复制到索引零,索引p + 1处的字符被复制到索引1,依此类推,直到索引limit()的字符被复制到索引n = limit() - 1 - p 然后将缓冲区的位置设置为n + 1,并将其限制设置为其容量。 标记如果被定义,则被丢弃。

        缓冲区的位置设置为复制的字符数,而不是零,因此可以通过调用另一个相对put方法来立即调用此方法。

        结果
        这个缓冲区
        异常
        ReadOnlyBufferException - 如果这个缓冲区是只读的
      • isDirect

        public abstract boolean isDirect​()
        告诉这个char缓冲区是否直接。
        Specified by:
        isDirectBuffer
        结果
        true如果,只有这个缓冲区是直接的
      • hashCode

        public int hashCode​()
        返回此缓冲区的当前哈希码。

        char缓冲区的哈希码仅依赖于它的剩余元素; 也就是说,元素从position()直到并包括元素在limit() - 1

        因为缓冲区哈希码是内容依赖的,所以使用缓冲区作为哈希映射或类似数据结构中的密钥是不合适的,除非知道它们的内容不会改变。

        重写:
        hashCodeObject
        结果
        这个缓冲区的当前哈希码
        另请参见:
        Object.equals(java.lang.Object)System.identityHashCode(java.lang.Object)
      • equals

        public boolean equals​(Object ob)
        告诉这个缓冲区是否等于另一个对象。

        两个char缓冲区是相等的,如果,只有这样,

        1. 它们具有相同的元素类型,

        2. 他们有相同数量的剩余元素,和

        3. 独立于其起始位置的剩余元素的两个序列是相等的。

        char缓冲区不等于任何其他类型的对象。

        重写:
        equalsObject
        参数
        ob - 要比较此缓冲区的对象
        结果
        true如果,并且只有当这个缓冲区等于给定的对象
        另请参见:
        Object.hashCode()HashMap
      • compareTo

        public int compareTo​(CharBuffer that)
        将此缓冲区与另一个缓冲区进

        通过比较其字母顺序的剩余元素序列来比较两个字符缓冲区,而不考虑其相应缓冲区内每个序列的起始位置。 char元素进行比较,仿佛通过调用Character.compare(char,char)

        char缓冲区与任何其他类型的对象不可比较。

        Specified by:
        compareTo在接口 Comparable<CharBuffer>
        参数
        that - 要比较的对象。
        结果
        负整数,零或正整数,因为此缓冲区小于,等于或大于给定的缓冲区
      • toString

        public String toString​()
        返回一个包含此缓冲区中字符的字符串。

        结果字符串的第一个字符将是此缓冲区位置的字符,而最后一个字符将是索引号limit() - 1处的字符。调用此方法不会更改缓冲区的位置。

        Specified by:
        toString在接口 CharSequence
        重写:
        toStringObject
        结果
        指定的字符串
      • length

        public final int length​()
        返回此字符缓冲区的长度。

        当被视为字符序列时,字符缓冲区的长度只是位置(包括)和限制(排除)之间的字符数; 也就是说,它相当于remaining()

        Specified by:
        length在接口 CharSequence
        结果
        这个字符缓冲区的长度
      • charAt

        public final char charAt​(int index)
        以相对于当前位置的给定索引读取字符。
        Specified by:
        charAt在接口 CharSequence
        参数
        index - 要读取的字符的索引,相对于位置; 必须是非负数,小于remaining()
        结果
        索引号为 position() + index的字符
        异常
        IndexOutOfBoundsException -如果前提 index不成立
      • subSequence

        public abstract CharBuffer subSequence​(int start,
                                               int end)
        创建一个新的字符缓冲区,代表该缓冲区相对于当前位置的指定子序列。

        新缓冲区将共享此缓冲区的内容; 也就是说,如果此缓冲区的内容是可变的,则对一个缓冲区的修改将导致另一个缓冲区被修改。 新缓冲区的容量将是这个缓冲区的容量,其位置将为position() + start ,其限制将为position() + end 如果只有这个缓冲区是直接的,并且只有当这个缓冲区是只读的时,这个缓冲区将是只读的。

        Specified by:
        subSequence在接口 CharSequence
        参数
        start - 子序列中第一个字符的相对于当前位置的索引; 必须是非负数,不得大于remaining()
        end - 子序列中最后一个字符之后的字符的相对于当前位置的索引; 必须不小于start ,不得大于remaining()
        结果
        新的字符缓冲区
        异常
        IndexOutOfBoundsException - 如果 startend的前提条件不成立
      • append

        public CharBuffer append​(CharSequence csq)
        将指定的字符序列追加到此缓冲区(可选操作)

        对这种dst.append(csq)形式的方法的调用与调用的方式完全相同

          dst.put(csq.toString()) 

        取决于规范toString字符序列csq ,整个序列可以不追加。 例如,调用字符缓冲区的toString方法将返回其内容取决于缓冲区的位置和限制的子序列。

        Specified by:
        append在接口 Appendable
        参数
        csq - 要追加的字符序列。 如果csqnull ,则四个字符"null"附加到该字符缓冲区。
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        ReadOnlyBufferException - 如果此缓冲区是只读的
        从以下版本开始:
        1.5
      • append

        public CharBuffer append​(CharSequence csq,
                                 int start,
                                 int end)
        将指定字符序列的子序列附加到此缓冲区(可选操作)

        形式的这种方法的调用dst.append(csq, start, end)csq不是null ,行为以完全相同的方式调用

          dst.put(csq.subSequence(start, end).toString()) 
        Specified by:
        append在接口 Appendable
        参数
        csq - 附加子序列的字符序列。 如果csqnull ,则会附加字符,因为csq包含四个字符"null"
        start - 子序列中第一个字符的索引
        end - 子序列中最后一个字符后面的字符的索引
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区中没有足够的空间
        IndexOutOfBoundsException - 如果 startend为负,则 start大于 end ,或 end大于 csq.length()
        ReadOnlyBufferException - 如果此缓冲区是只读的
        从以下版本开始:
        1.5
      • append

        public CharBuffer append​(char c)
        将指定的字符追加到此缓冲区(可选操作)

        对这种dst.append(c)形式的方法的调用与调用的方式完全相同

          dst.put(c) 
        Specified by:
        append在接口 Appendable
        参数
        c - 要追加的16位字符
        结果
        这个缓冲区
        异常
        BufferOverflowException - 如果此缓冲区空间不足
        ReadOnlyBufferException - 如果此缓冲区是只读的
        从以下版本开始:
        1.5
      • order

        public abstract ByteOrder order​()
        检索此缓冲区的字节顺序。

        通过分配或通过包装现有的char阵列创建的char缓冲区的字节顺序是底层硬件的native order 作为字节缓冲区的view创建的char缓冲区的字节顺序是创建视图时的字节缓冲区的字节顺序。

        结果
        这个缓冲区的字节顺序
      • chars

        public IntStream chars​()
        说明从接口CharSequence复制
        返回一个int的流,从这个序列中扩展char值。 映射到surrogate code point的任何字符将通过未解释的方式传递。

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

        Specified by:
        chars在接口 CharSequence
        结果
        这个序列中的char值的IntStream