java.lang.Object

java.nio.Buffer

java.nio.CharBuffer

所有已实现的接口:: Appendable, CharSequence, Comparable<CharBuffer>, Readable

public abstract sealed class CharBuffer extends Buffer implements Comparable<CharBuffer>, Appendable, CharSequence, Readable

一个char缓冲区。

此类定义了对char缓冲区的四类操作：

绝对和相对的get和put方法，用于读取和写入单个字符；
绝对和相对的bulk get方法，将连续的字符序列从此缓冲区传输到数组中；
绝对和相对的bulk put方法，将连续的字符序列从字符数组、字符串或其他char缓冲区传输到此缓冲区；
用于压缩char缓冲区的方法。

Char缓冲区可以通过分配、将现有的字符数组或字符串包装到缓冲区中，或者创建现有字节缓冲区的视图来创建。

与字节缓冲区一样，char缓冲区可以是直接的或非直接的。通过此类的wrap方法创建的char缓冲区将是非直接的。如果char缓冲区作为字节缓冲区的视图创建，那么只有当字节缓冲区本身是直接的时，char缓冲区才会是直接的。可以通过调用isDirect方法来确定char缓冲区是否是直接的。

此类实现了CharSequence接口，以便字符缓冲区可以在接受字符序列的任何地方使用，例如在正则表达式包java.util.regex中。当调用CharSequence定义的方法时，它们相对于调用它们时的缓冲区的当前位置进行操作。

在此类中，没有其他返回值的方法被指定为在调用它们时返回缓冲区。这允许方法调用被链接。例如，语句序列

    cb.put("text/");
    cb.put(subtype);
    cb.put("; charset=");
    cb.put(enc);

可以被替换为单个语句

    cb.put("text/").put(subtype).put("; charset=").put(enc);

可选操作

指定为可选操作的方法在对只读CharBuffer调用时会抛出ReadOnlyBufferException。如果CharBuffer不是由可访问的char数组支持的，则方法array和arrayOffset会抛出UnsupportedOperationException。

自:: 1.4

Method Summary

Modifier and Type

Method

Description

static CharBuffer

allocate(int capacity)

分配一个新的char缓冲区。

CharBuffer

append(char c)

将指定的字符追加到此缓冲区  (可选操作)。

CharBuffer

append(CharSequence csq)

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

CharBuffer

append(CharSequence csq, int start, int end)

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

final char[]

array()

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

final int

arrayOffset()

返回缓冲区的第一个元素在其支持数组中的偏移量  (可选操作)。

abstract CharBuffer

asReadOnlyBuffer()

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

final char

charAt(int index)

读取相对于当前位置给定索引处的字符。

final CharBuffer

clear()

清除此缓冲区。

abstract CharBuffer

compact()

压缩此缓冲区  (可选操作)。

int

compareTo(CharBuffer that)

将此缓冲区与另一个缓冲区进行比较。

abstract CharBuffer

duplicate()

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

boolean

equals(Object ob)

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

final CharBuffer

flip()

翻转此缓冲区。

abstract char

get()

相对的get方法。

CharBuffer

get(char[] dst)

相对的批量get方法。

CharBuffer

get(char[] dst, int offset, int length)

相对的批量get方法。

abstract char

get(int index)

绝对的get方法。

CharBuffer

get(int index, char[] dst)

绝对的批量get方法。

CharBuffer

get(int index, char[] dst, int offset, int length)

绝对的批量get方法。

final boolean

hasArray()

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

int

hashCode()

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

abstract boolean

isDirect()

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

final boolean

isEmpty()

如果此字符缓冲区为空，则返回true。

final int

length()

返回此字符缓冲区的长度。

final CharBuffer

limit(int newLimit)

设置此缓冲区的限制。

final CharBuffer

mark()

在其位置设置此缓冲区的标记。

int

mismatch(CharBuffer that)

查找并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。

abstract ByteOrder

order()

检索此缓冲区的字节顺序。

final CharBuffer

position(int newPosition)

设置此缓冲区的位置。

abstract CharBuffer

put(char c)

相对的put方法  (可选操作)。

final CharBuffer

put(char[] src)

相对的批量put方法  (可选操作)。

CharBuffer

put(char[] src, int offset, int length)

相对的批量put方法  (可选操作)。

abstract CharBuffer

put(int index, char c)

绝对的put方法  (可选操作)。

CharBuffer

put(int index, char[] src)

绝对的批量put方法  (可选操作)。

CharBuffer

put(int index, char[] src, int offset, int length)

绝对的批量put方法  (可选操作)。

CharBuffer

put(int index, CharBuffer src, int offset, int length)

绝对的批量put方法  (可选操作)。

final CharBuffer

put(String src)

相对的批量put方法  (可选操作)。

CharBuffer

put(String src, int start, int end)

相对的批量put方法  (可选操作)。

CharBuffer

put(CharBuffer src)

相对的批量put方法  (可选操作)。

int

read(CharBuffer target)

尝试将字符读入指定的字符缓冲区。

final CharBuffer

reset()

将此缓冲区的位置重置为先前标记的位置。

final CharBuffer

rewind()

倒带此缓冲区。

abstract CharBuffer

slice()

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

abstract CharBuffer

slice(int index, int length)

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

abstract CharBuffer

subSequence(int start, int end)

创建一个新的字符缓冲区，表示相对于当前位置的此缓冲区的指定子序列。

String

toString()

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

static CharBuffer

wrap(char[] array)

将字符数组包装成缓冲区。

static CharBuffer

wrap(char[] array, int offset, int length)

将字符数组包装成缓冲区。

static CharBuffer

wrap(CharSequence csq)

将字符序列包装成缓冲区。

static CharBuffer

wrap(CharSequence csq, int start, int end)

将字符序列包装成缓冲区。

Methods declared in class java.nio.Buffer
capacity, hasRemaining, isReadOnly, limit, position, remaining

Methods declared in class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods declared in interface java.lang.CharSequence
chars, codePoints

Method Details
- allocate
  
  public static CharBuffer allocate(int capacity)
  
  分配一个新的char缓冲区。
  新缓冲区的位置将为零，限制将为其容量，标记将为未定义，每个元素将初始化为零，其字节顺序将是底层硬件的本机顺序。它将有一个支持数组，其数组偏移量将为零。
  
  参数:
  
  capacity - 新缓冲区的容量，以字符为单位
  
  返回:
  
  新的char缓冲区
  
  抛出:
  
  IllegalArgumentException - 如果capacity是负整数
- wrap
  
  public static CharBuffer wrap(char[] array, int offset, int length)
  
  将字符数组包装成缓冲区。
  新缓冲区将由给定的字符数组支持；也就是说，对缓冲区的修改将导致数组被修改，反之亦然。新缓冲区的容量将为array.length，其位置将为offset，其限制将为offset + length，其标记将为未定义，其字节顺序将是底层硬件的本机顺序。其支持数组将是给定数组，其数组偏移量将为零。
  
  参数:
  
  array - 将支持新缓冲区的数组
  
  offset - 要使用的子数组的偏移量；必须是非负数且不大于array.length。新缓冲区的位置将设置为此值。
  
  length - 要使用的子数组的长度；必须是非负数且不大于array.length - offset。新缓冲区的限制将设置为offset + length。
  
  返回:
  
  新的char缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果offset和length参数的前提条件不成立
- wrap
  
  public static CharBuffer wrap(char[] array)
  
  Wraps a char array into a buffer.
  The new buffer will be backed by the given char array; that is, modifications to the buffer will cause the array to be modified and vice versa. The new buffer's capacity and limit will be array.length, its position will be zero, its mark will be undefined, and its byte order will be the native order of the underlying hardware. Its backing array will be the given array, and its array offset will be zero.
  
  Parameters:
  
  array - The array that will back this buffer
  
  Returns:
  
  The new char buffer
- read
  
  public int read(CharBuffer target) throws IOException
  
  Attempts to read characters into the specified character buffer. The buffer is used as a repository of characters as-is: the only changes made are the results of a put operation. No flipping or rewinding of the buffer is performed.
  
  Specified by:
  
  read in interface Readable
  
  Parameters:
  
  target - the buffer to read characters into
  
  Returns:
  
  The number of characters added to the buffer, or -1 if this source of characters is at its end
  
  Throws:
  
  IOException - if an I/O error occurs
  
  ReadOnlyBufferException - if target is a read only buffer
  
  Since:
  
  1.5
- wrap
  
  public static CharBuffer wrap(CharSequence csq, int start, int end)
  
  Wraps a character sequence into a buffer.
  The content of the new, read-only buffer will be the content of the given character sequence. The buffer's capacity will be csq.length(), its position will be start, its limit will be end, and its mark will be undefined.
  
  Parameters:
  
  csq - The character sequence from which the new character buffer is to be created
  
  start - The index of the first character to be used; must be non-negative and no larger than csq.length(). The new buffer's position will be set to this value.
  
  end - The index of the character following the last character to be used; must be no smaller than start and no larger than csq.length(). The new buffer's limit will be set to this value.
  
  Returns:
  
  The new character buffer
  
  Throws:
  
  IndexOutOfBoundsException - If the preconditions on the start and end parameters do not hold
- wrap
  
  public static CharBuffer wrap(CharSequence csq)
  
  Wraps a character sequence into a buffer.
  The content of the new, read-only buffer will be the content of the given character sequence. The new buffer's capacity and limit will be csq.length(), its position will be zero, and its mark will be undefined.
  
  Parameters:
  
  csq - The character sequence from which the new character buffer is to be created
  
  Returns:
  
  The new character buffer
- slice
  
  public abstract CharBuffer slice()
  
  Creates a new char buffer whose content is a shared subsequence of this buffer's content.
  The content of the new buffer will start at this buffer's current position. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent.
  
  The new buffer's position will be zero, its capacity and its limit will be the number of chars remaining in this buffer, its mark will be undefined, and its byte order will be identical to that of this buffer. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.
  
  Specified by:
  
  slice in class Buffer
  
  Returns:
  
  The new char buffer
- slice
  
  public abstract CharBuffer slice(int index, int length)
  
  Creates a new char buffer whose content is a shared subsequence of this buffer's content.
  The content of the new buffer will start at position index in this buffer, and will contain length elements. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent.
  
  The new buffer's position will be zero, its capacity and its limit will be length, its mark will be undefined, and its byte order will be identical to that of this buffer. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.
  
  Specified by:
  
  slice in class Buffer
  
  Parameters:
  
  index - The position in this buffer at which the content of the new buffer will start; must be non-negative and no larger than limit()
  
  length - The number of elements the new buffer will contain; must be non-negative and no larger than limit() - index
  
  Returns:
  
  The new buffer
  
  Throws:
  
  IndexOutOfBoundsException - If index is negative or greater than limit(), length is negative, or length > limit() - index
  
  Since:
  
  13
- duplicate
  
  public abstract CharBuffer duplicate()
  
  Creates a new char buffer that shares this buffer's content.
  The content of the new buffer will be that of this buffer. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent.
  
  The new buffer's capacity, limit, position, mark values, and byte order will be identical to those of this buffer. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.
  
  Specified by:
  
  duplicate in class Buffer
  
  Returns:
  
  The new char buffer
- asReadOnlyBuffer
  
  public abstract CharBuffer asReadOnlyBuffer()
  
  Creates a new, read-only char buffer that shares this buffer's content.
  The content of the new buffer will be that of this buffer. Changes to this buffer's content will be visible in the new buffer; the new buffer itself, however, will be read-only and will not allow the shared content to be modified. The two buffers' position, limit, and mark values will be independent.
  
  The new buffer's capacity, limit, position, mark values, and byte order will be identical to those of this buffer.
  
  If this buffer is itself read-only then this method behaves in exactly the same way as the duplicate method.
  
  Returns:
  
  The new, read-only char buffer
- get
  
  public abstract char get()
  
  Relative get method. Reads the char at this buffer's current position, and then increments the position.
  
  Returns:
  
  The char at the buffer's current position
  
  Throws:
  
  BufferUnderflowException - If the buffer's current position is not smaller than its limit
- put
  
  public abstract CharBuffer put(char c)
  
  Relative put method (optional operation).
  Writes the given char into this buffer at the current position, and then increments the position.
  
  Parameters:
  
  c - The char to be written
  
  Returns:
  
  This buffer
  
  Throws:
  
  BufferOverflowException - If this buffer's current position is not smaller than its limit
  
  ReadOnlyBufferException - If this buffer is read-only
- get
  
  public abstract char get(int index)
  
  Absolute get method. Reads the char at the given index.
  
  Parameters:
  
  index - The index from which the char will be read
  
  Returns:
  
  The char at the given index
  
  Throws:
  
  IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
- put
  
  public abstract CharBuffer put(int index, char c)
  
  Absolute put method (optional operation).
  Writes the given char into this buffer at the given index.
  
  Parameters:
  
  index - The index at which the char will be written
  
  c - The char value to be written
  
  Returns:
  
  This buffer
  
  Throws:
  
  IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
  
  ReadOnlyBufferException - If this buffer is read-only
- get
  
  public CharBuffer get(char[] dst, int offset, int length)
  相对批量获取方法。
  此方法将此缓冲区中的字符传输到给定的目标数组中。如果缓冲区中剩余的字符少于满足请求所需的字符，也就是说，如果 length > remaining()，那么不会传输任何字符，并且会抛出 BufferUnderflowException。
  
  否则，此方法将从此缓冲区复制 length 个字符到给定的数组中，从该缓冲区的当前位置和数组中的给定偏移量开始。然后递增此缓冲区的位置 length。
  
  换句话说，形如 src.get(dst, off, len) 的此方法调用与以下循环具有完全相同的效果
  
  for (int i = off; i < off + len; i++) dst[i] = src.get();
  
  ，只是它首先检查此缓冲区中是否有足够的字符，并且可能更有效率。
  参数:
  
  dst - 要写入字符的数组
  
  offset - 要写入的第一个字符在数组中的偏移量；必须是非负的且不大于 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
- get
  
  public CharBuffer get(int index, char[] dst, int offset, int length)
  绝对批量获取方法。
  此方法将从此缓冲区中的给定索引开始的 length 个字符传输到给定数组中的给定偏移量处。此缓冲区的位置不变。
  
  形如 src.get(index, dst, offset, length) 的此方法调用与以下循环具有完全相同的效果，只是它首先检查所提供参数的一致性，并且可能更有效率：
  
  for (int i = offset, j = index; i < offset + length; i++, j++) dst[i] = src.get(j);
  参数:
  
  index - 从中读取第一个字符的此缓冲区中的索引；必须是非负的且小于 limit()
  
  dst - 目标数组
  
  offset - 要写入的第一个字符在数组中的偏移量；必须是非负的且小于 dst.length
  
  length - 要写入给定数组的字符数；必须是非负的且不大于 limit() - index 和 dst.length - offset 中较小的一个
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index、offset 和 length 参数的前提条件不成立
  
  自:
  
  13
- get
  
  public CharBuffer get(int index, char[] dst)
  绝对批量获取方法。
  此方法将此缓冲区中的字符传输到给定目标数组中。此缓冲区的位置不变。形如 src.get(index, dst) 的此方法调用的行为与以下调用完全相同：
  
  src.get(index, dst, 0, dst.length)
  参数:
  
  index - 从中读取第一个字符的此缓冲区中的索引；必须是非负的且小于 limit()
  
  dst - 目标数组
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index 为负数、不小于 limit()，或者 limit() - index < dst.length
  
  自:
  
  13
- put
  
  public CharBuffer put(CharBuffer src)
  相对批量放置方法 (可选操作)。
  此方法将给定源缓冲区中剩余的字符传输到此缓冲区中。如果源缓冲区中剩余的字符多于此缓冲区中的字符，也就是说，如果 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(int index, CharBuffer src, int offset, int length)
  绝对批量放置方法 (可选操作)。
  此方法从给定源缓冲区中的给定 offset 开始的 length 个字符传输到此缓冲区中的给定 index 处。两个缓冲区的位置不变。
  
  换句话说，形如 dst.put(index, src, offset, length) 的此方法调用与以下循环具有完全相同的效果
  
  for (int i = offset, j = index; i < offset + length; i++, j++) dst.put(j, src.get(i));
  
  ，只是它首先检查所提供参数的一致性，并且可能更有效率。如果此缓冲区和源缓冲区共享相同的后备数组或内存，则结果将是源元素首先被复制到中间位置，然后再写入此缓冲区。
  参数:
  
  index - 将写入第一个字符的此缓冲区中的索引；必须是非负的且小于 limit()
  
  src - 要从中读取字符的缓冲区
  
  offset - 要读取的第一个字符在源缓冲区中的索引；必须是非负的且小于 src.limit()
  
  length - 要从给定缓冲区中读取的字符数；必须是非负的且不大于 limit() - index 和 src.limit() - offset 中较小的一个
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index、offset 和 length 参数的前提条件不成立
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
  
  自:
  
  16
- put
  
  public CharBuffer put(char[] src, int offset, int length)
  相对批量 put 方法 (可选操作)。
  此方法从给定的源数组将字符传输到此缓冲区中。如果要从数组中复制的字符多于此缓冲区中剩余的字符，即如果 length > remaining()，则不会传输任何字符，并且将抛出 BufferOverflowException。
  
  否则，此方法将从给定数组中复制 length 个字符到此缓冲区中，从数组中的给定偏移量和此缓冲区的当前位置开始。然后，此缓冲区的位置将增加 length。
  
  换句话说，形式为 dst.put(src, off, len) 的此方法的调用与以下循环具有完全相同的效果
  
  for (int i = off; i < off + len; i++) dst.put(src[i]);
  
  ，只是它首先检查此缓冲区中是否有足够的空间，并且可能更有效率。
  参数:
  
  src - 要从中读取字符的数组
  
  offset - 要读取的第一个字符在数组中的偏移量；必须是非负的且不大于 src.length
  
  length - 要从给定数组中读取的字符数；必须是非负的且不大于 src.length - offset
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中空间不足
  
  IndexOutOfBoundsException - 如果 offset 和 length 参数的前提条件不成立
  
  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(int index, char[] src, int offset, int length)
  绝对批量 put 方法 (可选操作)。
  此方法从给定数组中的给定偏移量和此缓冲区中的给定索引开始传输 length 个字符。此缓冲区的位置不变。
  
  形式为 dst.put(index, src, offset, length) 的此方法的调用与以下循环具有完全相同的效果，只是它首先检查所提供参数的一致性，并且可能更有效率：
  
  for (int i = offset, j = index; i < offset + length; i++, j++) dst.put(j, src[i]);
  参数:
  
  index - 将写入第一个字符的此缓冲区中的索引；必须是非负的且小于 limit()
  
  src - 要从中读取字符的数组
  
  offset - 要读取的第一个字符在数组中的偏移量；必须是非负的且小于 src.length
  
  length - 要从给定数组中读取的字符数；必须是非负的且不大于 limit() - index 和 src.length - offset 中较小的一个
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index、offset 和 length 参数的前提条件不成立
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
  
  自:
  
  13
- put
  
  public CharBuffer put(int index, char[] src)
  绝对批量 put 方法 (可选操作)。
  此方法从给定源数组中复制字符到此缓冲区中。此缓冲区的位置不变。形式为 dst.put(index, src) 的此方法的调用行为与以下调用完全相同：
  
  dst.put(index, src, 0, src.length);
  参数:
  
  index - 将写入第一个字符的此缓冲区中的索引；必须是非负的且小于 limit()
  
  src - 要从中读取字符的数组
  
  返回:
  
  此缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果 index 为负数、不小于 limit()，或者 limit() - index < src.length
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
  
  自:
  
  13
- 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) 的此方法的调用与以下循环具有完全相同的效果
  
  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)
  相对批量 put 方法 (可选操作)。
  此方法将给定源字符串的整个内容传输到此缓冲区中。形式为 dst.put(s) 的此方法的调用行为与以下调用完全相同
  
  dst.put(s, 0, s.length())
  参数:
  
  src - 源字符串
  
  返回:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中空间不足
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- hasArray
  
  public final boolean hasArray()
  
  告知此缓冲区是否由可访问的字符数组支持。
  如果此方法返回 true，则可以安全地调用 array 和 arrayOffset 方法。
  
  指定者:
  
  hasArray 在类 Buffer 中
  
  返回:
  
  如果且仅如果此缓冲区由数组支持且不是只读的，则返回 true
- array
  
  public final char[] array()
  
  返回支持此缓冲区的字符数组 (可选操作)。
  修改此缓冲区的内容将导致返回的数组的内容被修改，反之亦然。
  
  在调用此方法之前，请调用 hasArray 方法，以确保此缓冲区具有可访问的支持数组。
  
  指定由：
  
  array 在类 Buffer中
  
  返回：
  
  支持此缓冲区的数组
  
  抛出：
  
  ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读的
  
  UnsupportedOperationException - 如果此缓冲区没有可访问的数组支持
- arrayOffset
  
  public final int arrayOffset()
  
  返回此缓冲区的支持数组中第一个元素的偏移量 (可选操作)。
  如果此缓冲区由数组支持，则缓冲区位置 p 对应于数组索引 p + arrayOffset()。
  
  在调用此方法之前，请调用hasArray方法，以确保此缓冲区具有可访问的支持数组。
  
  指定由：
  
  arrayOffset 在类 Buffer中
  
  返回：
  
  此缓冲区数组中第一个元素的偏移量
  
  抛出：
  
  ReadOnlyBufferException - 如果此缓冲区由数组支持但是只读的
  
  UnsupportedOperationException - 如果此缓冲区没有可访问的数组支持
- position
  
  public final CharBuffer position(int newPosition)
  
  设置此缓冲区的位置。如果标记已定义且大于新位置，则将其丢弃。
  
  覆盖：
  
  position 在类 Buffer中
  
  参数：
  
  newPosition - 新位置值；必须是非负数且不大于当前限制
  
  返回：
  
  此缓冲区
  
  自：
  
  9
- limit
  
  public final CharBuffer limit(int newLimit)
  
  设置此缓冲区的限制。如果位置大于新限制，则将其设置为新限制。如果标记已定义且大于新限制，则将其丢弃。
  
  覆盖：
  
  limit 在类 Buffer中
  
  参数：
  
  newLimit - 新限制值；必须是非负数且不大于此缓冲区的容量
  
  返回：
  
  此缓冲区
  
  自：
  
  9
- mark
  
  public final CharBuffer mark()
  
  在其位置设置此缓冲区的标记。
  
  覆盖：
  
  mark 在类 Buffer中
  
  返回：
  
  此缓冲区
  
  自：
  
  9
- reset
  
  public final CharBuffer reset()
  
  将此缓冲区的位置重置为先前标记的位置。
  调用此方法既不更改也不丢弃标记的值。
  
  覆盖：
  
  reset 在类 Buffer中
  
  返回：
  
  此缓冲区
  
  自：
  
  9
- clear
  
  public final CharBuffer clear()
  清除此缓冲区。位置设置为零，限制设置为容量，并丢弃标记。
  在使用一系列通道读取或 put 操作填充此缓冲区之前，请调用此方法。例如：
  
  buf.clear(); // 准备缓冲区进行读取 in.read(buf); // 读取数据
  
  此方法实际上不会擦除缓冲区中的数据，但它的命名方式表明它可能会在那种情况下使用。
  覆盖：
  
  clear 在类 Buffer中
  
  返回：
  
  此缓冲区
  
  自：
  
  9
- flip
  
  public final CharBuffer flip()
  翻转此缓冲区。限制设置为当前位置，然后位置设置为零。如果标记已定义，则将其丢弃。
  在一系列通道读取或 put 操作之后，调用此方法以准备进行一系列通道写入或相对 get 操作。例如：
  
  buf.put(magic); // 在头部添加 in.read(buf); // 将数据读入缓冲区的其余部分 buf.flip(); // 翻转缓冲区 out.write(buf); // 将头部 + 数据写入通道
  
  此方法通常与 compact 方法一起在将数据从一个地方传输到另一个地方时使用。
  覆盖：
  
  flip 在类 Buffer中
  
  返回：
  
  此缓冲区
  
  自：
  
  9
- rewind
  
  public final CharBuffer rewind()
  倒带此缓冲区。位置设置为零，标记丢弃。
  在一系列通道写入或 get 操作之前，请调用此方法，假设限制已经适当设置。例如：
  
  out.write(buf); // 写入剩余数据 buf.rewind(); // 倒带缓冲区 buf.get(array); // 将数据复制到数组中
  覆盖：
  
  rewind 在类 Buffer中
  
  返回：
  
  此缓冲区
  
  自：
  
  9
- compact
  
  public abstract CharBuffer compact()
  
  压缩此缓冲区 (可选操作)。
  如果有的话，缓冲区当前位置和限制之间的字符将被复制到缓冲区的开头。也就是说，索引 p 处的字符（p = position()）将被复制到索引零处，索引 p + 1 处的字符将被复制到索引一处，依此类推，直到索引 limit() - 1 处的字符被复制到索引 n = limit() - 1 - p 处。然后，缓冲区的位置设置为 n+1，其限制设置为其容量。如果定义了标记，则将其丢弃。
  
  缓冲区的位置设置为复制的字符数，而不是零，以便可以立即调用另一个相对 put 方法。
  
  返回：
  
  此缓冲区
  
  抛出：
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
- isDirect
  
  public abstract boolean isDirect()
  
  告诉此字符缓冲区是否是直接的。
  
  指定由：
  
  isDirect 在类 Buffer中
  
  返回：
  
  如果此缓冲区是直接的，则返回true
- hashCode
  
  public int hashCode()
  
  返回此缓冲区的当前哈希码。
  字符缓冲区的哈希码仅取决于其剩余元素；也就是说，取决于从 position() 开始到 limit() - 1 处的元素。
  
  由于缓冲区哈希码是内容相关的，因此不建议将缓冲区用作哈希映射或类似数据结构中的键，除非知道它们的内容不会更改。
  覆盖：
  
  hashCode 在类 Object中
  
  返回：
  
  此缓冲区的当前哈希码
  
  参见：
  
  Object.equals(java.lang.Object)
  
  System.identityHashCode(java.lang.Object)
- equals
  
  public boolean equals(Object ob)
  告诉此缓冲区是否等于另一个对象。
  如果，且仅如果，两个字符缓冲区相等
  
  它们具有相同的元素类型，
  
  它们具有相同数量的剩余元素，并且
  
  两个剩余元素序列，独立于它们的起始位置，是逐点相等的。
  
  字符缓冲区不等于任何其他类型的对象。
  覆盖：
  
  equals 在类 Object中
  
  参数：
  
  ob - 要将此缓冲区与之比较的对象
  
  返回：
  
  如果，且仅如果，此缓冲区等于给定对象，则返回true
  
  参见：
  
  Object.hashCode()
  
  HashMap
- compareTo
  
  public int compareTo(CharBuffer that)
  
  将此缓冲区与另一个进行比较。
  通过按字典顺序比较剩余元素序列来比较两个字符缓冲区，而不考虑每个序列在其相应缓冲区内的起始位置。一对 char 元素的比较就像调用 Character.compare(char,char) 一样。
  
  字符缓冲区与任何其他类型的对象都不可比较。
  
  指定者:
  
  compareTo 在接口 Comparable<CharBuffer>中
  
  参数:
  
  that - 要比较的对象。
  
  返回值:
  
  如果此缓冲区小于、等于或大于给定缓冲区，则返回负整数、零或正整数
- mismatch
  
  public int mismatch(CharBuffer that)
  
  找到并返回此缓冲区与给定缓冲区之间第一个不匹配的相对索引。索引是相对于每个缓冲区的position，将在0（包括）到每个缓冲区中剩余元素的较小值（不包括）的范围内。
  如果两个缓冲区共享一个公共前缀，则返回的索引是公共前缀的长度，因此在各自缓冲区中的该索引处存在不匹配。如果一个缓冲区是另一个缓冲区的正确前缀，则返回的索引是每个缓冲区中剩余元素的较小值，因此该索引仅对具有较大剩余元素数量的缓冲区有效。否则，没有不匹配。
  
  参数:
  
  that - 要与此缓冲区进行比较的字节缓冲区
  
  返回值:
  
  此缓冲区与给定缓冲区之间第一个不匹配的相对索引，否则如果没有不匹配则为-1。
  
  自:
  
  11
- toString
  
  public String toString()
  
  返回包含此缓冲区中字符的字符串。
  结果字符串的第一个字符将是此缓冲区位置处的字符，而最后一个字符将是索引limit() - 1处的字符。调用此方法不会更改缓冲区的位置。
  
  指定者:
  
  toString 在接口 CharSequence中
  
  覆盖:
  
  toString 在类 Object中
  
  返回值:
  
  指定的字符串
- length
  
  public final int length()
  
  返回此字符缓冲区的长度。
  将字符缓冲区视为字符序列时，字符缓冲区的长度只是位置（包括）和限制（不包括）之间的字符数；也就是说，它等同于remaining()。
  
  指定者:
  
  length 在接口 CharSequence中
  
  返回值:
  
  此字符缓冲区的长度
- isEmpty
  
  public final boolean isEmpty()
  
  如果此字符缓冲区为空，则返回true。
  
  指定者:
  
  isEmpty 在接口 CharSequence中
  
  返回值:
  
  如果剩余字符数为0，则返回true，否则返回false
  
  自:
  
  15
- charAt
  
  public final char charAt(int index)
  
  读取相对于当前位置的给定索引处的字符。
  
  指定者:
  
  charAt 在接口 CharSequence中
  
  参数:
  
  index - 要读取的字符的索引，相对于位置；必须是非负数且小于remaining()
  
  返回值:
  
  位置position() + index处的字符
  
  抛出:
  
  IndexOutOfBoundsException - 如果index上的前提条件不成立
- subSequence
  
  public abstract CharBuffer subSequence(int start, int end)
  
  创建一个新的字符缓冲区，表示相对于当前位置的指定子序列。
  新缓冲区将共享此缓冲区的内容；也就是说，如果此缓冲区的内容是可变的，则对一个缓冲区的修改将导致另一个缓冲区被修改。新缓冲区的容量将是此缓冲区的容量，其位置将是position() + start，其限制将是position() + end，其字节顺序将与此缓冲区相同。如果此缓冲区是直接缓冲区，则新缓冲区也将是直接缓冲区，如果此缓冲区是只读的，则新缓冲区也将是只读的。
  
  指定者:
  
  subSequence 在接口 CharSequence中
  
  参数:
  
  start - 子序列中第一个字符的索引，相对于当前位置；必须是非负数且不大于remaining()
  
  end - 子序列中最后一个字符之后的字符的索引，相对于当前位置；必须不小于start且不大于remaining()
  
  返回值:
  
  新字符缓冲区
  
  抛出:
  
  IndexOutOfBoundsException - 如果start和end上的前提条件不成立
- append
  
  public CharBuffer append(CharSequence csq)
  将指定的字符序列追加到此缓冲区 (可选操作)。
  以dst.append(csq)形式调用此方法的行为与调用
  
  dst.put(csq.toString())
  
  根据字符序列csq的toString规范，可能不会追加整个序列。例如，调用字符缓冲区的toString方法将返回一个子序列，其内容取决于缓冲区的位置和限制。
  指定者:
  
  append 在接口 Appendable中
  
  参数:
  
  csq - 要追加的字符序列。如果csq为null，则将四个字符"null"追加到此字符缓冲区。
  
  返回值:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中空间不足
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
  
  自:
  
  1.5
- append
  
  public CharBuffer append(CharSequence csq, int start, int end)
  将指定字符序列的子序列追加到此缓冲区 (可选操作)。
  当csq不为null时，以dst.append(csq, start, end)形式调用此方法的行为与调用
  
  dst.put(csq.subSequence(start, end).toString())
  指定者:
  
  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)
  将指定的字符追加到此缓冲区 (可选操作)。
  以dst.append(c)形式调用此方法的行为与调用
  
  dst.put(c)
  指定者:
  
  append 在接口 Appendable中
  
  参数:
  
  c - 要追加的16位字符
  
  返回值:
  
  此缓冲区
  
  抛出:
  
  BufferOverflowException - 如果此缓冲区中空间不足
  
  ReadOnlyBufferException - 如果此缓冲区是只读的
  
  自:
  
  1.5
- order
  
  public abstract ByteOrder order()
  
  检索此缓冲区的字节顺序。
  通过分配或包装现有的char数组创建的char缓冲区的字节顺序是底层硬件的本机顺序。通过字节缓冲区的视图创建的char缓冲区的字节顺序是在创建视图时字节缓冲区的字节顺序。
  
  返回：
  
  此缓冲区的字节顺序

Class CharBuffer

可选操作

Method Summary

Methods declared in class java.nio.Buffer

Methods declared in class java.lang.Object

Methods declared in interface java.lang.CharSequence

Method Details

allocate

wrap

wrap

read

wrap

wrap

slice

slice

duplicate

asReadOnlyBuffer

get

put

get

put

get

get

get

get

put

put

put

put

put

put

put

put

hasArray

array

arrayOffset

position

limit

mark

reset

clear

flip

rewind

compact

isDirect

hashCode

equals

compareTo

mismatch

toString

length

isEmpty

charAt

subSequence

append

append

append

order