方法详细信息

• 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 - 如果 offset和 length参数的前提条件不成立

• 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 - 如果target为null

  ReadOnlyBufferException - 如果target是只读缓冲区

  从以下版本开始：

  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 - 如果 start和 end参数的前提条件不成立

• wrap

  public static CharBuffer wrap​(CharSequence csq)

  将字符序列包装到缓冲区中。

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

  参数

  csq - 要从中创建新字符缓冲区的字符序列

  结果

  新的字符缓冲区

• slice

  public abstract CharBuffer slice()

  创建一个新的char缓冲区，其内容是此缓冲区内容的共享子序列。

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

  新缓冲区的位置将为零，其容量和限制将是此缓冲区中剩余的字符数，其标记将是未定义的，其字节顺序将与此缓冲区的字节顺序相同。 当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。

  Specified by:

  slice在类 Buffer

  结果

  新的char缓冲区

• duplicate

  public abstract CharBuffer duplicate()

  创建一个共享此缓冲区内容的新char缓冲区。

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

  新缓冲区的容量，限制，位置，标记值和字节顺序将与此缓冲区的容量，限制，位置，标记值和字节顺序相同。 当且仅当此缓冲区是直接缓冲区时，新缓冲区将是直接的，并且当且仅当此缓冲区是只读时，它才是只读的。

  Specified by:

  duplicate在类 Buffer

  结果

  新的char缓冲区

• asReadOnlyBuffer

  public abstract CharBuffer asReadOnlyBuffer()

  创建一个共享此缓冲区内容的新的只读char缓冲区。

  新缓冲区的内容将是此缓冲区的内容。 对此缓冲区内容的更改将在新缓冲区中可见; 但是，新缓冲区本身将是只读的，不允许修改共享内容。 两个缓冲区的位置，限制和标记值将是独立的。

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

  如果此缓冲区本身是只读的，则此方法的行为方式与duplicate方法完全相同。

  结果

  新的只读字符缓冲区

• get

  public abstract char get()

  相对get方法。 读取此缓冲区当前位置的char，然后递增位置。

  结果

  缓冲区当前位置的字符

  异常

  BufferUnderflowException - 如果缓冲区的当前位置不小于其限制

• put

  public abstract CharBuffer put​(char c)

  相对put方法（可选操作） 。

  将给定的char写入当前位置的缓冲区，然后递增位置。

  参数

  c - c的字符

  结果

  这个缓冲区

  异常

  BufferOverflowException - 如果此缓冲区的当前位置不小于其限制

  ReadOnlyBufferException - 如果此缓冲区是只读的

• get

  public abstract char get​(int index)

  绝对获取方法。 读取给定索引处的char。

  参数

  index - 将从中读取char的索引

  结果

  给定索引处的char

  异常

  IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制

• put

  public abstract CharBuffer put​(int index,
                                 char c)

  绝对放法（可选操作） 。

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

  参数

  index - 将写入char的索引

  c - 要写入的char值

  结果

  这个缓冲区

  异常

  IndexOutOfBoundsException - 如果 index为负数或不小于缓冲区的限制

  ReadOnlyBufferException - 如果此缓冲区是只读的

• get

  public CharBuffer get​(char[] dst,
                        int offset,
                        int length)

  相对批量获取方法。

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

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

  换句话说，调用src.get(dst, off, len)形式的此方法与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 - 如果 offset和 length参数的前提条件不成立

• get

  public CharBuffer get​(char[] dst)

  相对批量获取方法。

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

    src.get(a, 0, a.length) 

  参数

  dst - 目标阵列

  结果

  这个缓冲区

  异常

  BufferUnderflowException - 如果此缓冲区中剩余的字符数少于 length

• put

  public CharBuffer put​(CharBuffer src)

  相对批量放置方法（可选操作） 。

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

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

  换句话说，调用dst.put(src)形式的此方法与dst.put(src)具有完全相同的效果

    while (src.hasRemaining())
           dst.put(src.get()); 

  除了它首先检查此缓冲区中是否有足够的空间，它可能更有效。

  参数

  src - 要从中读取字符的源缓冲区; 一定不能是这个缓冲区

  结果

  这个缓冲区

  异常

  BufferOverflowException - 如果此缓冲区中没有足够的空间用于源缓冲区中的剩余字符

  IllegalArgumentException - 如果源缓冲区是此缓冲区

  ReadOnlyBufferException - 如果此缓冲区是只读的

• put

  public CharBuffer put​(char[] src,
                        int offset,
                        int length)

  相对批量放置方法（可选操作） 。

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

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

  换句话说，调用dst.put(src, off, len)形式的此方法与dst.put(src, off, len)具有完全相同的效果

     for (int i = off; i < off + len; i++) dst.put(a[i]);  

  除了它首先检查此缓冲区中是否有足够的空间，它可能更有效。

  参数

  src - 要从中读取字符的数组

  offset - 要读取的第一个char的数组中的偏移量; 必须是非负数且不大于array.length

  length - 要从给定数组中读取的字符数; 必须是非负数且不大于array.length - offset

  结果

  这个缓冲区

  异常

  BufferOverflowException - 如果此缓冲区中没有足够的空间

  IndexOutOfBoundsException - 如果 offset和 length参数的前提条件不成立

  ReadOnlyBufferException - 如果此缓冲区是只读的

• put

  public final CharBuffer put​(char[] src)

  相对批量放置方法（可选操作） 。

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

    dst.put(a, 0, a.length) 

  参数

  src - 源数组

  结果

  这个缓冲区

  异常

  BufferOverflowException - 如果此缓冲区中没有足够的空间

  ReadOnlyBufferException - 如果此缓冲区是只读的

• put

  public CharBuffer put​(String src,
                        int start,
                        int end)

  相对批量放置方法（可选操作） 。

  此方法将字符从给定字符串传输到此缓冲区。 如果要从字符串中复制的字符数多于保留在此缓冲区中的字符数，即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 - 要读取的最后一个字符串的字符串中的偏移量加一; 必须是非负数且不大于string.length()

  结果

  这个缓冲区

  异常

  BufferOverflowException - 如果此缓冲区中没有足够的空间

  IndexOutOfBoundsException - 如果 start和 end参数的前提条件不成立

  ReadOnlyBufferException - 如果此缓冲区是只读的

• put

  public final CharBuffer put​(String src)

  相对批量放置方法（可选操作） 。

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

    dst.put(s, 0, s.length()) 

  参数

  src - 源字符串

  结果

  这个缓冲区

  异常

  BufferOverflowException - 如果此缓冲区中没有足够的空间

  ReadOnlyBufferException - 如果此缓冲区是只读的

• hasArray

  public final boolean hasArray()

  判断此缓冲区是否由可访问的char数组支持。

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

  Specified by:

  hasArray在类 Buffer

  结果

  true当且仅当此缓冲区由数组支持且不是只读时

• array

  public final char[] array()

  返回支持此缓冲区的char数组（可选操作） 。

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

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

  Specified by:

  array在类 Buffer

  结果

  支持此缓冲区的数组

  异常

  ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读

  UnsupportedOperationException - 如果此缓冲区未由可访问的阵列支持

• arrayOffset

  public final int arrayOffset()

  返回此缓冲区缓冲区第一个元素的后备数组中的偏移量（可选操作） 。

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

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

  Specified by:

  arrayOffset在类 Buffer

  结果

  缓冲区第一个元素的缓冲区数组中的偏移量

  异常

  ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读

  UnsupportedOperationException - 如果此缓冲区未由可访问的阵列支持

• compact

  public abstract CharBuffer compact()

  压缩此缓冲区（可选操作） 。

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

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

  结果

  这个缓冲区

  异常

  ReadOnlyBufferException - 如果此缓冲区是只读的

• isDirect

  public abstract boolean isDirect()

  判断此char缓冲区是否是直接的。

  Specified by:

  isDirect在类 Buffer

  结果

  true当且仅当此缓冲区是直接的

• hashCode

  public int hashCode()

  返回此缓冲区的当前哈希码。

  char缓冲区的哈希码仅取决于其剩余的元素; 也就是说，来自position()的元素直到并包括元素limit() - 1 。

  因为缓冲区哈希码是依赖于内容的，所以不建议使用缓冲区作为哈希映射或类似数据结构中的键，除非已知它们的内容不会改变。

  重写：

  hashCode在类 Object

  结果

  此缓冲区的当前哈希码

  另请参见：

  Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)

• equals

  public boolean equals​(Object ob)

  判断此缓冲区是否等于另一个对象。

  两个char缓冲区相等，当且仅当，

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

  2. 它们具有相同数量的剩余元素，并且

  3. 与其起始位置无关地考虑的两个剩余元素序列是逐点相等的。

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

  重写：

  equals在类 Object

  参数

  ob - 要与此缓冲区进行比较的对象

  结果

  true当且仅当此缓冲区等于给定对象时

  另请参见：

  Object.hashCode() ， HashMap

• compareTo

  public int compareTo​(CharBuffer that)

  比较此缓冲区与另一个缓冲区。

  通过按字典顺序比较它们的剩余元素序列来比较两个char缓冲区，而不考虑每个序列在其相应缓冲区内的起始位置。 成对的char元素通过调用Character.compare(char,char)进行比较。

  char缓冲区与任何其他类型的对象都不具有可比性。

  Specified by:

  compareTo在界面 Comparable<CharBuffer>

  参数

  that - 要比较的对象。

  结果

  此缓冲区小于，等于或大于给定缓冲区的负整数，零或正整数

• mismatch

  public int mismatch​(CharBuffer that)

  查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。 索引相对于每个缓冲区的position ，并且将在0（包括）范围内，直到每个缓冲区中的较小的remaining元素（不包括）。

  如果两个缓冲区共享一个公共前缀，则返回的索引是公共前缀的长度，并且随后在相应缓冲区内该索引处的两个缓冲区之间存在不匹配。 如果一个缓冲区是另一个缓冲区的正确前缀，则返回的索引是每个缓冲区中剩余元素中较小的一个，并且随后索引仅对具有较多剩余元素的缓冲区有效。 否则，没有不匹配。

  参数

  that - 要测试与此缓冲区不匹配的字节缓冲区

  结果

  此与给定缓冲区之间的第一个不匹配的相对索引，否则为-1，如果没有不匹配。

  从以下版本开始：

  11

• toString

  public String toString()

  返回包含此缓冲区中字符的字符串。

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

  Specified by:

  toString在界面 CharSequence

  重写：

  toString在类 Object

  结果

  指定的字符串

• 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 - 如果 start和 end的前提条件不成立

• append

  public CharBuffer append​(CharSequence csq)

  将指定的字符序列追加到此缓冲区（可选操作） 。

  调用dst.append(csq)形式的此方法的行为与调用的方式完全相同

    dst.put(csq.toString()) 

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

  Specified by:

  append在接口 Appendable

  参数

  csq - 要追加的字符序列。 如果csq是null ，则四个字符"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 - 将附加子序列的字符序列。 如果csq是null ，则将附加字符，就像csq包含四个字符"null" 。

  start - 子序列中第一个字符的索引

  end - 子序列中最后一个字符后面的字符的索引

  结果

  这个缓冲区

  异常

  BufferOverflowException - 如果此缓冲区中没有足够的空间

  IndexOutOfBoundsException - 如果 start或 end为负数，则 start大于 end ，或 end大于 csq.length()

  ReadOnlyBufferException - 如果此缓冲区是只读的

  从以下版本开始：

  1.5

• append

  public CharBuffer append​(char c)

  将指定的char追加到此缓冲区（可选操作） 。

  调用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创建的字符缓冲区的字节顺序是创建视图时字节缓冲区的字节顺序。

  结果

  此缓冲区的字节顺序